@sentry/junior 0.144.0 → 0.146.0

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

@@ -7,7 +7,7 @@ import {
   PluginCredentialFailureError,
   agentNameSchema,
   createPluginAuthOrchestration
-} from "./chunk-DVO5VKYQ.js";
+} from "./chunk-FEKQHPVA.js";
 import {
   authorizationId
 } from "./chunk-DIB4GX3G.js";
@@ -28,7 +28,7 @@ import {
   patchMcpAuthSession,
   selectPluginGrant,
   toMcpProviderError
-} from "./chunk-BBCWYXHB.js";
+} from "./chunk-47OSH2ZO.js";
 import {
   RetryableDeliveryError,
   actorFromRouting,
@@ -44,12 +44,12 @@ import {
   getSlackMessagePermalink,
   resolveBaseUrl,
   uploadFilesToConversation
-} from "./chunk-KQBXT5B7.js";
+} from "./chunk-ZDGHGY74.js";
 import {
   estimateTextTokens,
   getAgentContextCompactionTriggerTokens,
   getAgentContextInputLimitTokens
-} from "./chunk-CNTWB2SM.js";
+} from "./chunk-T5GXFFLA.js";
 import {
   AGENTS_REMOVAL_NOTICE,
   AGENTS_REPLACEMENT_NOTICE,
@@ -66,6 +66,7 @@ import {
   canReusePendingAuthLink,
   collectFiles,
   containsNoReplyMarker,
+  continuableMessages,
   decideReply,
   extractAssistantText,
   findSingleRepositoryDirectory,
@@ -86,17 +87,13 @@ import {
   isTurnInputCommitLostError,
   loadConnectedMcpProviders,
   loadConversationProjection,
+  loadTurnCheckpoint,
   loadTurnRoute,
-  loadTurnSessionRecord,
   mergeArtifactsState,
   missingPathSearchResult,
   normalizeToLf,
   normalizeToolNameFromResult,
   openConversationProjection,
-  persistAuthPauseSessionRecord,
-  persistContinuationSessionRecord,
-  persistRunningSessionRecord,
-  persistYieldSessionRecord,
   piMessageFromHistoryItem,
   positiveInteger,
   recordAgentsInstructionsUpdated,
@@ -110,10 +107,11 @@ import {
   resolveWorkspacePath,
   retainRuntimeTurnContext,
   sanitizeAssistantText,
+  saveTurnCheckpoint,
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages,
   truncateText
-} from "./chunk-BEGGFVFR.js";
+} from "./chunk-GDQEU4I7.js";
 import {
   JUNIOR_THREAD_STATE_TTL_MS
 } from "./chunk-3Y47VMHV.js";
@@ -145,7 +143,7 @@ import {
   runNonInteractiveCommand,
   throwSandboxOperationError,
   wrapSandboxSetupError
-} from "./chunk-7KAW7UF4.js";
+} from "./chunk-FXDDDSPL.js";
 import {
   SCHEDULED_TASK_SYSTEM_ACTOR,
   compactEventTask,
@@ -177,15 +175,15 @@ import {
   saveEventTask,
   scheduledTaskAttributes,
   writableEventTask
-} from "./chunk-ZZCTGAIT.js";
+} from "./chunk-X22KCSCO.js";
 import {
   parseSlackThreadId
-} from "./chunk-PKH6762I.js";
+} from "./chunk-PH4Q3A6W.js";
 import {
   SHORT_TITLE_MAX_LENGTH,
   generateShortTitle,
   resolveTaskTitle
-} from "./chunk-54JMYQYS.js";
+} from "./chunk-W65V465O.js";
 import {
   ToolInputError,
   addAgentTurnUsage,
@@ -203,7 +201,7 @@ import {
   getSlackToolContext,
   readActorIdentity,
   resolveChannelCapabilities
-} from "./chunk-44RJWAND.js";
+} from "./chunk-SCGVWUZX.js";
 import {
   SlackActionError,
   downloadPrivateSlackFile,
@@ -212,18 +210,23 @@ import {
   isConversationScopedChannel,
   normalizeSlackConversationId,
   withSlackRetries
-} from "./chunk-QE3TICD4.js";
+} from "./chunk-V6SRLKUB.js";
 import {
   KNOWN_CONVERSATION_EVENT_TYPES,
   contextProvenance,
   getConversationEventStore,
-  getConversationSearchStore,
+  getConversationMessageSearchStore,
   getConversationStore,
   getDb,
+  getSqlExecutor,
   instructionActors,
   instructionProvenanceFor,
-  sameActorIdentity
-} from "./chunk-SBZP2J5Q.js";
+  sameActorIdentity,
+  upsertIdentity
+} from "./chunk-37EVZP66.js";
+import {
+  juniorIdentities
+} from "./chunk-MCFIXAV5.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
@@ -235,7 +238,7 @@ import {
 } from "./chunk-EM225ITJ.js";
 import {
   getStateAdapter
-} from "./chunk-UDQMY6RS.js";
+} from "./chunk-GYEKOX7N.js";
 import {
   ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX,
   COMPACTION_SUMMARY_PREFIX,
@@ -263,13 +266,12 @@ import {
   modelIdForProfile,
   modelProfileSchema,
   normalizeSlackEmojiName,
-  parseTurnReasoningLevel,
   profileConfig,
   renderCurrentInstruction,
   resolveGatewayCredential,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-3GU4PWA3.js";
+} from "./chunk-MKRIZ4VG.js";
 import {
   canExposeConversationPayload,
   resolveConversationPrivacy,
@@ -279,16 +281,16 @@ import {
   toGenAiMessagesTraceAttributes,
   toGenAiPayloadMetadata,
   toGenAiPayloadTraceAttributes
-} from "./chunk-STFCL3K4.js";
+} from "./chunk-QG7OOKIN.js";
 import {
   discoverSkills,
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-SUK7NC5A.js";
+} from "./chunk-FGHADGIC.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-ZF3N3JD6.js";
+} from "./chunk-PB222GIA.js";
 import {
   CredentialUnavailableError,
   OAuthProviderError,
@@ -296,7 +298,7 @@ import {
   getOAuthProviderErrorAttributes,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv
-} from "./chunk-A67GZN73.js";
+} from "./chunk-37JJDS4H.js";
 import {
   credentialUserSubjectId
 } from "./chunk-RUIXF3YQ.js";
@@ -318,6 +320,7 @@ import {
   logInfo,
   logWarn,
   normalizeGenAiFinishReason,
+  normalizeIdentityEmail,
   serializeGenAiAttribute,
   setSpanAttributes,
   setSpanStatus,
@@ -325,7 +328,7 @@ import {
   summarizeMessageText,
   withLogContext,
   withSpan
-} from "./chunk-RIFJUJSI.js";
+} from "./chunk-B63BF443.js";
 import {
   startInactiveSpan,
   withActiveSpan
@@ -1404,21 +1407,6 @@ function actionConfirmationRetryMessages(messages) {
   return retryMessages;
 }
 
-// src/chat/agent/session.ts
-async function restoreSessionRecord(args) {
-  const sessionRecordState = await loadTurnSessionRecord({
-    conversationId: args.conversationId,
-    sessionId: args.turnId
-  });
-  const { resumedFromSessionRecord, currentSliceId, existingSessionRecord } = sessionRecordState;
-  return {
-    currentSliceId,
-    existingSessionRecord,
-    resumedFromSessionRecord,
-    sessionRecordState
-  };
-}
-
 // src/chat/mcp/tool-name.ts
 function parseMcpProviderFromToolName(toolName) {
   if (!toolName.startsWith("mcp__")) return void 0;
@@ -1590,7 +1578,6 @@ async function restoreSkillRuntime(args) {
     const restoredSkill = await args.skillSandbox.loadSkill(skillName);
     if (restoredSkill) {
       upsertActiveSkill(args.activeSkills, restoredSkill);
-      args.syncLoadedSkillNamesForResume();
     }
   }
   if (args.invokedSkill) {
@@ -1599,7 +1586,6 @@ async function restoreSkillRuntime(args) {
     );
     if (restoredSkill) {
       upsertActiveSkill(args.activeSkills, restoredSkill);
-      args.syncLoadedSkillNamesForResume();
     }
   }
 }
@@ -8149,7 +8135,7 @@ function createSearchResourceEventTypesTool(catalog) {
     outputSchema: outputSchema2,
     async execute({ query, namespace, maxResults }) {
       const normalizedQuery = normalizeSearchText(query ?? "");
-      const terms = normalizedQuery.split(/\s+/).filter(Boolean);
+      const terms2 = normalizedQuery.split(/\s+/).filter(Boolean);
       const matches = searchableResourceTypes(catalog).filter(
         (resourceType) => {
           if (namespace && resourceType.namespace !== namespace) return false;
@@ -8161,7 +8147,7 @@ function createSearchResourceEventTypesTool(catalog) {
               ...resourceType.suggestedEvents ?? []
             ].join(" ")
           );
-          return terms.every((term) => text.includes(term));
+          return terms2.every((term) => text.includes(term));
         }
       );
       const resourceTypes = matches.slice(
@@ -9833,32 +9819,63 @@ function createSlackChannelListMessagesTool(context) {
   });
 }
 
-// src/chat/slack/tools/conversation-search.ts
+// src/chat/slack/tools/conversation-message-search.ts
 import { z as z37 } from "zod";
+
+// src/chat/conversations/tool-source.ts
+var CONVERSATIONS_TOOL_SOURCE = {
+  id: "conversations",
+  description: "Search messages and events in retained Junior conversations."
+};
+
+// src/chat/slack/tools/conversation-message-search.ts
 var DEFAULT_LIMIT = 5;
-var conversationSearchOutputSchema = juniorToolOutputSchema.extend({
-  query: z37.string(),
+var conversationMessageSearchOutputSchema = juniorToolOutputSchema.extend({
+  channel_id: z37.string().min(1).optional(),
   count: z37.number().int().nonnegative(),
-  threads: z37.array(
+  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),
-      thread_ts: z37.string().min(1),
+      excerpt: z37.string(),
       message_id: z37.string().min(1),
       message_role: z37.enum(["assistant", "user"]),
       message_timestamp: z37.string().datetime(),
-      excerpt: z37.string(),
-      permalink: z37.string().url().optional()
+      permalink: z37.string().url().optional(),
+      thread_ts: z37.string().min(1)
     }).strict()
   )
 });
-function createSlackConversationSearchTool(scope, currentConversationId, deps = {}) {
+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 (!query && !channelId) {
+    throw new ToolInputError(
+      "Provide at least one of `query` or `channel_id`."
+    );
+  }
+  return {
+    ...channelId ? { channelId } : {},
+    ...query ? { query } : {}
+  };
+}
+function createSlackConversationMessageSearchTool(scope, currentConversationId, deps = {}) {
   return zodTool({
-    description: "Search prior public Junior conversation threads across the current Slack workspace. Use when the user refers to an earlier public discussion, decision, or answer that is not in the current thread. Searches retained visible user and assistant messages only.",
+    description: "Search retained user and assistant messages in public Junior conversations across the current Slack workspace. Excludes the current conversation.",
     exposure: "deferred",
-    source: {
-      id: "conversation-history",
-      description: "Search retained public Junior conversation threads in the current Slack workspace."
-    },
+    source: CONVERSATIONS_TOOL_SOURCE,
     annotations: {
       destructiveHint: false,
       idempotentHint: true,
@@ -9866,20 +9883,24 @@ function createSlackConversationSearchTool(scope, currentConversationId, deps =
       readOnlyHint: true
     },
     inputSchema: z37.object({
-      query: z37.string().trim().min(1).max(200).describe("Words or a short phrase to find in prior conversations."),
-      limit: z37.number().int().min(1).max(10).describe("Maximum number of prior conversation threads to return.").nullable().optional()
-    }),
-    outputSchema: conversationSearchOutputSchema,
-    execute: async ({ query, limit }) => {
-      const store = deps.store ?? getConversationSearchStore();
+      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()
+    }).strict(),
+    outputSchema: conversationMessageSearchOutputSchema,
+    execute: async (input) => {
+      const filters = resolveSearchFilters(input);
+      const store = deps.store ?? getConversationMessageSearchStore();
       const matches = await store.search({
         currentConversationId,
-        limit: limit ?? DEFAULT_LIMIT,
-        query,
+        filters,
+        limit: input.limit ?? DEFAULT_LIMIT,
         scope
       });
       const getPermalink = deps.getPermalink ?? getSlackMessagePermalink;
-      const threads = await Promise.all(
+      const matchesOutput = await Promise.all(
         matches.map(async (match) => {
           const reference = parseSlackThreadId(match.conversationId);
           if (!reference || reference.channelId !== match.providerDestinationId) {
@@ -9898,14 +9919,17 @@ function createSlackConversationSearchTool(scope, currentConversationId, deps =
             message_role: match.role,
             message_timestamp: new Date(match.messageCreatedAtMs).toISOString(),
             excerpt: match.excerpt,
+            channel_id: match.providerDestinationId,
+            ...match.channelName ? { channel_name: match.channelName } : {},
             ...permalink ? { permalink } : {}
           };
         })
       );
       return {
-        query,
-        count: threads.length,
-        threads
+        ...filters.query ? { query: filters.query } : {},
+        ...filters.channelId ? { channel_id: filters.channelId } : {},
+        count: matchesOutput.length,
+        matches: matchesOutput
       };
     }
   });
@@ -11311,7 +11335,100 @@ function parseSlackMessageReference(input) {
   };
 }
 
-// src/chat/slack/legacy-attachments.ts
+// src/chat/slack/message/blocks.ts
+var MAX_BLOCKS = 50;
+var MAX_CHILDREN = 50;
+var MAX_DEPTH = 16;
+var MAX_NODES = 5e3;
+var CHILD_KEYS = [
+  "blocks",
+  "elements",
+  "fields",
+  "accessory",
+  "element",
+  "rows",
+  "cells"
+];
+function toText(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readText(value) {
+  if (typeof value === "string") return toText(value);
+  if (!value || typeof value !== "object") return void 0;
+  return toText(value.text);
+}
+function parseChildren(value, budget, depth) {
+  if (Array.isArray(value)) {
+    return value.slice(0, MAX_CHILDREN).flatMap((child) => parseChildren(child, budget, depth));
+  }
+  return parseElement(value, budget, depth);
+}
+function parseElement(value, budget, depth) {
+  if (!value || typeof value !== "object" || depth > MAX_DEPTH || budget.remainingNodes <= 0) {
+    return [];
+  }
+  budget.remainingNodes -= 1;
+  const element = value;
+  const type = toText(element.type);
+  const text = readText(element.text);
+  if (type === "link") {
+    const url = toText(element.url);
+    return [
+      text && url && text !== url ? `${text} (${url})` : text || url
+    ].filter((part) => Boolean(part));
+  }
+  if (type === "button") {
+    const url = toText(element.url);
+    return [text && url ? `${text} (${url})` : text].filter(
+      (part) => Boolean(part)
+    );
+  }
+  if (type === "emoji") {
+    const name = toText(element.name);
+    return name ? [`:${name}:`] : [];
+  }
+  if (type === "user") {
+    const userId = toText(element.user_id);
+    return userId ? [`<@${userId}>`] : [];
+  }
+  if (type === "channel") {
+    const channelId = toText(element.channel_id);
+    return channelId ? [`<#${channelId}>`] : [];
+  }
+  if (type === "usergroup") {
+    const usergroupId = toText(element.usergroup_id);
+    return usergroupId ? [`<!subteam^${usergroupId}>`] : [];
+  }
+  if (type === "broadcast") {
+    const range = toText(element.range);
+    return range ? [`<!${range}>`] : [];
+  }
+  const parts = [
+    text,
+    readText(element.title),
+    readText(element.description),
+    readText(element.label),
+    readText(element.hint),
+    readText(element.placeholder),
+    toText(element.alt_text),
+    toText(element.provider_name),
+    toText(element.fallback)
+  ].filter((part) => Boolean(part));
+  for (const key of CHILD_KEYS) {
+    parts.push(...parseChildren(element[key], budget, depth + 1));
+  }
+  if (type === "checkboxes" || type === "radio_buttons") {
+    parts.push(...parseChildren(element.options, budget, depth + 1));
+  }
+  return parts;
+}
+function renderBlockText(value) {
+  if (!Array.isArray(value)) return "";
+  const budget = { remainingNodes: MAX_NODES };
+  return value.slice(0, MAX_BLOCKS).flatMap((block) => parseElement(block, budget, 0)).join("\n");
+}
+
+// src/chat/slack/message/attachments.ts
 var MAX_ATTACHMENTS = 10;
 var MAX_FIELDS_PER_ATTACHMENT = 20;
 var MAX_FIELD_CHARS = 1e3;
@@ -11349,6 +11466,7 @@ function renderAttachment(raw) {
   const text = toStr(obj.text);
   const footer = toStr(obj.footer);
   const fields = Array.isArray(obj.fields) ? obj.fields : [];
+  const blockText = renderBlockText(obj.blocks);
   const add = (value) => {
     if (!value) return;
     const normalized = normalizeAttachmentText(value);
@@ -11356,7 +11474,7 @@ function renderAttachment(raw) {
     seen.add(normalized);
     parts.push(normalized);
   };
-  const hasRichContent = pretext || title || text;
+  const hasRichContent = pretext || title || text || blockText;
   if (!hasRichContent) {
     add(fallback);
   }
@@ -11372,28 +11490,19 @@ function renderAttachment(raw) {
   for (const field of fields.slice(0, MAX_FIELDS_PER_ATTACHMENT)) {
     add(renderField(field));
   }
+  add(blockText);
   add(footer);
   return parts.join("\n");
 }
-function renderSlackLegacyAttachmentText(input) {
+function renderAttachmentText(input) {
   const rendered = getAttachmentPayload(input).slice(0, MAX_ATTACHMENTS).map(renderAttachment).filter((line) => line.length > 0).map((line) => `[attachment] ${line}`).join("\n");
   return rendered.slice(0, MAX_ATTACHMENT_TEXT_CHARS);
 }
-function appendSlackLegacyAttachmentText(baseText, rawMessageOrAttachments) {
-  const base = baseText?.trim() ?? "";
-  const attachmentText = renderSlackLegacyAttachmentText(
-    rawMessageOrAttachments
-  );
-  if (!attachmentText) return base;
-  if (!base) return attachmentText;
-  return `${base}
-${attachmentText}`;
-}
 
 // src/chat/slack/tools/thread-read.ts
 var MAX_THREAD_READ_CHARS = 4e4;
 function sanitizeMessage(msg) {
-  const attachmentText = renderSlackLegacyAttachmentText(msg.attachments);
+  const attachmentText = renderAttachmentText(msg.attachments);
   return {
     ts: msg.ts,
     user: msg.user,
@@ -11534,6 +11643,10 @@ 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;
@@ -11674,7 +11787,6 @@ async function searchSlackUsers(options) {
 }
 
 // src/chat/slack/tools/user-lookup.ts
-import { z as z50 } from "zod";
 function explicitUserLookupError(error) {
   if (error.apiError === "user_not_found") {
     return "No Slack user found for the supplied user ID.";
@@ -11693,9 +11805,52 @@ function explicitUserLookupError(error) {
   }
   return void 0;
 }
-function createSlackUserLookupTool() {
+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 } : {}
+  });
+}
+async function storedUserByEmail(teamId, email) {
+  const emailNormalized = normalizeIdentityEmail(email);
+  if (!emailNormalized) return void 0;
+  const identities = await getSqlExecutor().db().select().from(juniorIdentities).where(
+    and(
+      eq(juniorIdentities.provider, "slack"),
+      eq(juniorIdentities.providerTenantId, teamId),
+      eq(juniorIdentities.kind, "user"),
+      eq(juniorIdentities.emailVerified, true),
+      eq(juniorIdentities.emailNormalized, emailNormalized)
+    )
+  ).limit(2);
+  if (identities.length > 1) {
+    throw new Error(
+      `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
+  };
+}
+function createSlackUserLookupTool(teamId) {
   return zodTool({
-    description: "Look up Slack user profiles by user ID, email, or name search. Set mode to match the identifier in value. Returns profile fields including title, status, and custom fields.",
+    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.",
     annotations: {
       destructiveHint: false,
       idempotentHint: true,
@@ -11718,20 +11873,33 @@ function createSlackUserLookupTool() {
           if (!parsedUserId.ok) {
             throw new ToolInputError(parsedUserId.error);
           }
+          const user = await lookupSlackUserProfile(parsedUserId.value);
+          await storeProfile(teamId, user);
           return {
             mode: "user_id",
-            user: await lookupSlackUserProfile(parsedUserId.value)
+            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
           };
         }
@@ -11741,6 +11909,9 @@ function createSlackUserLookupTool() {
           maxPages: 3,
           includeBots: false
         });
+        if (result.users.length === 1) {
+          await storeProfile(teamId, result.users[0]);
+        }
         return {
           mode: "query",
           query: value,
@@ -11748,7 +11919,10 @@ function createSlackUserLookupTool() {
           searched_pages: result.searched_pages,
           searched_user_count: result.searched_user_count,
           truncated: result.truncated,
-          users: result.users
+          users: result.users.map((user) => ({
+            ...user,
+            mention: slackMention(user.id)
+          }))
         };
       } catch (error) {
         if (error instanceof SlackActionError) {
@@ -11854,7 +12028,7 @@ function getTimeZoneOffsetMinutes(timestampMs, timezone) {
   return Math.round((timestampMs - asUtcMs) / 6e4);
 }
 
-// src/chat/tools/query-conversation-events.ts
+// src/chat/tools/search-conversation-events.ts
 import { z as z52 } from "zod";
 var DEFAULT_LIMIT3 = 25;
 var MAX_LIMIT = 100;
@@ -11862,40 +12036,26 @@ var MAX_EVENT_DATA_BYTES = 4e3;
 var MAX_EVENTS_JSON_BYTES = 2e4;
 var MAX_IDENTITY_CHARS = 256;
 var textEncoder = new TextEncoder();
-var CONVERSATION_EVENTS_TOOL_SOURCE = {
-  id: "conversation-events",
-  description: "Inspect Junior's durable conversation event log for debugging runtime behavior."
-};
 var knownEventTypeSchema = z52.enum(KNOWN_CONVERSATION_EVENT_TYPES);
 var projectedEventSchema = z52.object({
-  seq: z52.number().int().nonnegative().describe("Stable event position; use it for pagination bounds."),
-  history_version: z52.number().int().nonnegative().describe(
-    "Model-history generation. It increments when handoff or compaction replaces active model context."
-  ),
+  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 one was assigned."),
-  data: z52.record(z52.string(), z52.unknown()).describe(
-    "Event data. Oversized payloads are replaced by identifying fields, payload_omitted, and payload_json_bytes."
-  )
+  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.")
 }).strict();
-var queryConversationEventsOutputSchema = juniorToolOutputSchema.extend({
+var searchConversationEventsOutputSchema = juniorToolOutputSchema.extend({
   conversation_id: z52.string().min(1),
   events: z52.array(projectedEventSchema),
-  has_older: z52.boolean().describe(
-    "Whether matching events exist before this page; request them with before_seq set to the first returned seq."
-  ),
-  has_newer: z52.boolean().describe(
-    "Whether matching events exist after this page; request them with after_seq set to the last returned seq."
-  ),
-  omitted_event_count: z52.number().int().nonnegative().optional().describe(
-    "Fetched events omitted to keep this response bounded. Continue with the pagination cursor for the omitted direction."
-  )
+  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.")
 });
-function createQueryConversationEventsTool(context) {
+function createSearchConversationEventsTool(context) {
   return zodTool({
-    description: "Inspect Junior's stored turns, tool calls, handoffs, and compaction events when debugging its behavior. Returns events from the current conversation tree or another retained public conversation in the same Slack workspace, newest first by default.",
+    description: "Search the durable event log for one conversation, including messages, agent history, tool results, handoffs, and compactions. Defaults to the current conversation. Outside the current conversation tree, only retained public conversations in the current Slack workspace are accessible.",
     exposure: "deferred",
-    source: CONVERSATION_EVENTS_TOOL_SOURCE,
+    source: CONVERSATIONS_TOOL_SOURCE,
     annotations: {
       destructiveHint: false,
       idempotentHint: true,
@@ -11903,31 +12063,25 @@ function createQueryConversationEventsTool(context) {
       readOnlyHint: true
     },
     inputSchema: z52.object({
-      conversation_id: z52.string().trim().min(1).describe(
-        "Conversation ID to inspect, such as slack:{channelId}:{threadTs} or a child conversation id."
-      ),
-      after_seq: z52.number().int().nonnegative().nullable().describe(
-        "Exclusive lower bound on event seq. When set, returns the next newer page in ascending order."
-      ).optional(),
-      before_seq: z52.number().int().nonnegative().nullable().describe(
-        "Exclusive upper bound on event seq. Combine with defaults or after_seq to page older or bounded ranges."
+      conversation_id: z52.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(
-        `Maximum events to return. Defaults to ${DEFAULT_LIMIT3}; max ${MAX_LIMIT}.`
+        `Maximum events. Default ${DEFAULT_LIMIT3}; max ${MAX_LIMIT}.`
       ).optional(),
-      types: z52.array(knownEventTypeSchema).min(1).nullable().describe(
-        "Optional event-type filter. Omit to return every durable event type."
-      ).optional()
+      types: z52.array(knownEventTypeSchema).min(1).nullable().describe("Event types to include; omit for all types.").optional()
     }).strict(),
-    outputSchema: queryConversationEventsOutputSchema,
+    outputSchema: searchConversationEventsOutputSchema,
     execute: async (input) => {
       const currentConversationId = context.conversationId?.trim();
       if (!currentConversationId) {
         throw new ToolInputError(
-          "queryConversationEvents requires an active conversation"
+          "searchConversationEvents requires an active conversation"
         );
       }
-      const conversationId = input.conversation_id;
+      const conversationId = input.conversation_id?.trim() || currentConversationId;
       const afterSeq = input.after_seq ?? void 0;
       const beforeSeq = input.before_seq ?? void 0;
       const limit = input.limit ?? DEFAULT_LIMIT3;
@@ -11960,7 +12114,7 @@ function createQueryConversationEventsTool(context) {
       const targetRoot = targetRootConversationId === conversationId ? target : await conversationStore.get({
         conversationId: targetRootConversationId
       });
-      assertCanQueryConversationEvents({
+      assertCanSearchConversationEvents({
         accessScope,
         targetConversationId: conversationId,
         targetRootConversationId,
@@ -12038,7 +12192,7 @@ async function resolveRootConversationId(conversationStore, conversationId, pare
   }
   return conversationId;
 }
-function assertCanQueryConversationEvents(args) {
+function assertCanSearchConversationEvents(args) {
   const {
     accessScope,
     targetConversationId,
@@ -12865,7 +13019,7 @@ function createTools(availableSkills, hooks = {}, context, options = {}) {
     ...createScheduledTaskTools(context)
   };
   if (context.conversationId) {
-    tools.queryConversationEvents = createQueryConversationEventsTool(context);
+    tools.searchConversationEvents = createSearchConversationEventsTool(context);
   }
   if (context.supportsImageInput) {
     tools.viewImage = createViewImageTool(
@@ -12902,7 +13056,7 @@ function createTools(availableSkills, hooks = {}, context, options = {}) {
     tools.slackCanvasWrite = createSlackCanvasWriteTool(state);
     tools.slackThreadRead = createSlackThreadReadTool(slackContext);
     if (context.conversationId && slackContext.source.visibility === "public") {
-      tools.searchConversationHistory = createSlackConversationSearchTool(
+      tools.searchConversationMessages = createSlackConversationMessageSearchTool(
         {
           kind: "public_provider_tenant",
           provider: "slack",
@@ -12916,7 +13070,7 @@ function createTools(availableSkills, hooks = {}, context, options = {}) {
         context.slackActionToken
       );
     }
-    tools.slackUserLookup = createSlackUserLookupTool();
+    tools.slackUserLookup = createSlackUserLookupTool(slackContext.teamId);
     tools.slackListCreate = createSlackListCreateTool(state);
     tools.slackListAddItems = createSlackListAddItemsTool(state);
     tools.slackListGetItems = createSlackListGetItemsTool(state);
@@ -13561,6 +13715,46 @@ var SEARCH_TOOLS_NAME = "searchTools";
 var DEFAULT_MAX_RESULTS2 = 5;
 var MAX_RESULTS3 = 20;
 var MODEL_VISIBLE_DESCRIPTION_CAP = 180;
+var SEARCH_FIELD_WEIGHTS = [8, 4, 1];
+var BM25_K1 = 1.2;
+var BM25_B = 0.75;
+var SEARCH_STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "by",
+  "do",
+  "for",
+  "from",
+  "how",
+  "i",
+  "in",
+  "is",
+  "it",
+  "me",
+  "my",
+  "of",
+  "on",
+  "or",
+  "please",
+  "that",
+  "the",
+  "this",
+  "to",
+  "use",
+  "we",
+  "what",
+  "when",
+  "where",
+  "which",
+  "with",
+  "you",
+  "your"
+]);
 var searchToolsSourceSchema = z58.object({
   id: z58.string(),
   description: z58.string()
@@ -13585,8 +13779,26 @@ var searchToolsOutputSchema = juniorToolOutputSchema.extend({
   execution_tool: z58.literal("executeTool"),
   tools: z58.array(searchToolsToolSchema)
 }).strict();
-function normalize2(value) {
-  return value.toLowerCase().replace(/[^a-z0-9_]+/g, " ").trim();
+function terms(value) {
+  const chunks = value.match(/[\p{L}\p{N}]+/gu) ?? [];
+  const result = [];
+  for (const chunk of chunks) {
+    result.push(chunk.toLowerCase());
+    const expanded = chunk.replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().split(/\s+/);
+    if (expanded.length > 1) {
+      result.push(...expanded);
+    }
+  }
+  return result;
+}
+function queryTerms(query) {
+  return [
+    ...new Set(
+      terms(query).filter(
+        (term) => term.length >= 2 && !SEARCH_STOP_WORDS.has(term)
+      )
+    )
+  ];
 }
 function summarizeModelVisibleDescription(description) {
   const paragraph = description.split(/\n\s*\n/).map((part) => part.trim()).find(Boolean) ?? "";
@@ -13603,36 +13815,114 @@ function schemaText(schema) {
     return "";
   }
 }
-function searchableToolText2(name, definition) {
-  return normalize2(
-    [
-      name,
-      definition.identity?.id,
-      definition.identity?.name,
-      definition.identity?.plugin,
-      definition.source?.id,
-      definition.source?.description,
-      definition.description,
-      definition.promptSnippet,
-      ...definition.promptGuidelines ?? [],
-      schemaText(definition.inputSchema),
-      JSON.stringify(definition.annotations ?? {})
-    ].filter(Boolean).join(" ")
+function searchableToolFields(name, definition) {
+  return [
+    terms(
+      [
+        name,
+        definition.identity?.id,
+        definition.identity?.name,
+        definition.identity?.plugin
+      ].filter(Boolean).join(" ")
+    ),
+    terms(
+      [
+        definition.description,
+        definition.promptSnippet,
+        ...definition.promptGuidelines ?? []
+      ].filter(Boolean).join(" ")
+    ),
+    terms(
+      [
+        definition.source?.id,
+        definition.source?.description,
+        schemaText(definition.inputSchema),
+        schemaText(definition.annotations ?? {})
+      ].filter(Boolean).join(" ")
+    )
+  ];
+}
+function prepareSearchDocuments(tools, source) {
+  return Object.entries(tools).filter(
+    ([, definition]) => source ? definition.source?.id === source : true
+  ).map(([name, definition]) => ({
+    name,
+    fields: searchableToolFields(name, definition)
+  }));
+}
+function averageFieldLengths(documents) {
+  if (documents.length === 0) {
+    return SEARCH_FIELD_WEIGHTS.map(() => 0);
+  }
+  return SEARCH_FIELD_WEIGHTS.map(
+    (_, fieldIndex) => documents.reduce(
+      (total, document) => total + document.fields[fieldIndex].length,
+      0
+    ) / documents.length
   );
 }
+function documentFrequencies(documents) {
+  const frequencies = /* @__PURE__ */ new Map();
+  for (const document of documents) {
+    const uniqueTerms = new Set(document.fields.flat());
+    for (const term of uniqueTerms) {
+      frequencies.set(term, (frequencies.get(term) ?? 0) + 1);
+    }
+  }
+  return frequencies;
+}
+function scoreSearchDocument(document, query, frequencies, documentCount, averageLengths) {
+  return query.reduce((score, term) => {
+    const documentFrequency = frequencies.get(term) ?? 0;
+    if (documentFrequency === 0) {
+      return score;
+    }
+    const weightedTermFrequency = document.fields.reduce(
+      (weighted, field, fieldIndex) => {
+        const termFrequency = field.filter(
+          (candidate) => candidate === term
+        ).length;
+        if (termFrequency === 0) {
+          return weighted;
+        }
+        const averageLength = averageLengths[fieldIndex] ?? 0;
+        const lengthRatio = averageLength === 0 ? 1 : field.length / averageLength;
+        return weighted + SEARCH_FIELD_WEIGHTS[fieldIndex] * (termFrequency / (1 - BM25_B + BM25_B * lengthRatio));
+      },
+      0
+    );
+    if (weightedTermFrequency === 0) {
+      return score;
+    }
+    const inverseDocumentFrequency = Math.log(
+      1 + (documentCount - documentFrequency + 0.5) / (documentFrequency + 0.5)
+    );
+    return score + inverseDocumentFrequency * weightedTermFrequency * (BM25_K1 + 1) / (weightedTermFrequency + BM25_K1);
+  }, 0);
+}
 function searchCatalogTools(tools, query, source) {
-  const entries = Object.entries(tools).sort(
-    ([left], [right]) => left.localeCompare(right)
-  );
-  const sourceEntries = source ? entries.filter(([, definition]) => definition.source?.id === source) : entries;
-  if (!normalize2(query)) {
-    return sourceEntries.map(([name]) => name);
+  const documents = prepareSearchDocuments(tools, source);
+  if (!query.trim()) {
+    return documents.map(({ name }) => name).sort((left, right) => left.localeCompare(right));
+  }
+  const searchTerms = queryTerms(query);
+  if (searchTerms.length === 0) {
+    return [];
   }
-  const terms = normalize2(query).split(/\s+/).filter(Boolean);
-  return sourceEntries.filter(([name, definition]) => {
-    const text = searchableToolText2(name, definition);
-    return terms.every((term) => text.includes(term));
-  }).map(([name]) => name);
+  const averageLengths = averageFieldLengths(documents);
+  const frequencies = documentFrequencies(documents);
+  return documents.map((document) => ({
+    name: document.name,
+    score: scoreSearchDocument(
+      document,
+      searchTerms,
+      frequencies,
+      documents.length,
+      averageLengths
+    )
+  })).filter(({ score }) => score > 0).sort(
+    (left, right) => right.score - left.score || left.name.localeCompare(right.name)
+  ).map(({ name }) => name);
 }
 function callNotes(definition) {
   return [
@@ -15468,7 +15758,6 @@ async function wireAgentTools(args) {
         );
         const effective = resolvedSkill ?? loadedSkill;
         upsertActiveSkill(args.activeSkills, effective);
-        args.syncLoadedSkillNamesForResume();
         if (await mcpToolManager.activateForSkill(effective)) {
           await args.recordConnectedMcpProvider(effective.pluginProvider);
         }
@@ -15599,6 +15888,18 @@ function extractSliceUsage(messages, beforeMessageCount) {
   );
   return hasAgentTurnUsage(usage) ? usage : void 0;
 }
+function boundaryKey(messages) {
+  return messages.map((message) => {
+    const record2 = message;
+    const content = typeof record2.content === "string" ? record2.content : JSON.stringify(record2.content ?? null);
+    return [
+      String(record2.role ?? ""),
+      String(record2.timestamp ?? ""),
+      String(record2.toolCallId ?? ""),
+      content
+    ].join("
");
+  }).join("");
+}
 function createResumeState(args) {
   let beforeMessageCount = 0;
   let inputCommitted = false;
@@ -15607,19 +15908,26 @@ function createResumeState(args) {
   let resumeMessages = [];
   let turnContexts = [];
   let turnStartMessageIndex;
-  const currentSliceId = args.sessionRecordState.currentSliceId;
-  const currentDurationMs = () => Date.now() - args.startedAtMs;
-  const sessionRecordBase = () => ({
-    channelName: args.channelName,
+  let advancedPastResume = !args.checkpoint.resumed;
+  let resumedBoundaryKey = "";
+  if (args.checkpoint.resumed && args.checkpoint.record.piMessages.length) {
+    const prior = args.checkpoint.record;
+    latestSafeBoundaryMessages = [...prior.piMessages];
+    resumeMessages = [...prior.piMessages];
+    resumedBoundaryKey = boundaryKey(
+      continuableMessages(prior.piMessages, prior.piMessages)
+    );
+  }
+  const currentSliceId = args.checkpoint.sliceId;
+  const durationMs = () => Date.now() - args.startedAtMs;
+  const writeBase = () => ({
     conversationId: args.conversationId,
+    turnId: args.turnId,
+    channelName: args.channelName,
     destination: args.destination,
-    ...args.destinationVisibility ? { destinationVisibility: args.destinationVisibility } : {},
-    ...args.dispatchId ? { dispatchId: args.dispatchId } : {},
+    destinationVisibility: args.destinationVisibility,
+    dispatchId: args.dispatchId,
     source: args.runSource,
-    sessionId: args.turnId,
-    loadedSkillNames: args.getLoadedSkillNames(),
-    modelId: args.getModelId(),
-    ...args.getReasoningLevel() ? { reasoningLevel: args.getReasoningLevel() } : {},
     actor: args.actor,
     surface: args.surface
   });
@@ -15642,7 +15950,7 @@ function createResumeState(args) {
     setTurnContexts(contexts) {
       turnContexts = contexts;
     },
-    /** Adopt an already committed epoch replacement as every resume baseline. */
+    /** Use an already committed boundary as the resume baseline. */
     adoptCommittedBoundary(messages) {
       latestSafeBoundaryMessages = [...messages];
       resumeMessages = [...messages];
@@ -15664,18 +15972,23 @@ function createResumeState(args) {
       inputCommitted = true;
     },
     async persistSafeBoundary(messages, trailingMessageProvenance) {
-      const persisted = await persistRunningSessionRecord({
-        ...sessionRecordBase(),
+      const saved = await saveTurnCheckpoint({
+        mode: "running",
+        ...writeBase(),
         sliceId: currentSliceId,
         messages,
-        ...trailingMessageProvenance ? { trailingMessageProvenance } : {},
-        ...turnContexts.length > 0 ? { turnContexts } : {},
-        ...turnStartMessageIndex !== void 0 ? { turnStartMessageIndex } : {}
+        trailingMessageProvenance,
+        turnContexts: turnContexts.length > 0 ? turnContexts : void 0,
+        turnStartMessageIndex
       });
-      if (!persisted) {
+      if (!saved) {
         return false;
       }
       latestSafeBoundaryMessages = [...messages];
+      const persistedKey = boundaryKey(continuableMessages(messages, messages));
+      if (resumedBoundaryKey.length === 0 || persistedKey !== resumedBoundaryKey) {
+        advancedPastResume = true;
+      }
       return true;
     },
     async requireDurableInputCheckpoint(messages, trailingMessageProvenance) {
@@ -15690,34 +16003,34 @@ function createResumeState(args) {
       }
       return persisted;
     },
-    /** Prepare a cooperative yield at the current durable boundary. */
     prepareYieldIfDue(currentMessages) {
       if (!args.durability.shouldYield?.()) {
         return void 0;
       }
-      const nextResumeMessages = this.getResumeSnapshot(currentMessages);
-      if (!isContinuablePiBoundary(nextResumeMessages)) {
+      const next = this.getResumeSnapshot(currentMessages);
+      if (!isContinuablePiBoundary(next)) {
         return void 0;
       }
-      resumeMessages = nextResumeMessages;
+      resumeMessages = next;
       return new CooperativeTurnYieldError(
-        `Agent turn yielded at a safe boundary after ${currentDurationMs()}ms`
+        `Agent turn yielded at a safe boundary after ${durationMs()}ms`
       );
     },
-    /** Persist an auth pause; only a durable pause may return `awaiting_auth`. */
     async parkForAuth(pause, currentUsage) {
       const usage = currentUsage ?? (resumeMessages.length > 0 ? extractSliceUsage(resumeMessages, beforeMessageCount) : void 0);
       try {
         await args.recordActiveMcpProviders();
-        const sessionRecord = await persistAuthPauseSessionRecord({
-          ...sessionRecordBase(),
-          currentSliceId,
-          currentDurationMs: currentDurationMs(),
-          currentUsage: usage,
+        const record2 = await saveTurnCheckpoint({
+          mode: "paused",
+          reason: "auth",
+          ...writeBase(),
+          sliceId: currentSliceId,
+          durationMs: durationMs(),
+          usage,
           messages: resumeMessages,
           errorMessage: pause.message
         });
-        if (!sessionRecord) {
+        if (!record2) {
           throw new AuthPausePersistenceError(args.conversationId, args.turnId);
         }
         return {
@@ -15727,7 +16040,7 @@ function createResumeState(args) {
           ...usage ? { usage } : {}
         };
       } catch (error) {
-        if (error instanceof AuthPausePersistenceError) {
+        if (error instanceof AuthPausePersistenceError || error instanceof TurnSliceLimitExceededError) {
           throw error;
         }
         throw new AuthPausePersistenceError(
@@ -15737,62 +16050,61 @@ function createResumeState(args) {
         );
       }
     },
-    /** Persist a yield, retry, or timeout as a suspended run. */
     async translateSuspension(ending) {
       const { error } = ending;
-      if (error instanceof CooperativeTurnYieldError) {
-        const usage = ending.currentUsage ?? extractSliceUsage(resumeMessages, beforeMessageCount);
-        await args.recordActiveMcpProviders();
-        const sessionRecord = await persistYieldSessionRecord({
-          ...sessionRecordBase(),
-          currentSliceId,
-          currentDurationMs: currentDurationMs(),
-          currentUsage: usage,
-          messages: resumeMessages,
-          errorMessage: error.message
+      const reason = error instanceof CooperativeTurnYieldError ? "yield" : error instanceof RetryableDeliveryError ? "retry" : timedOut ? "timeout" : void 0;
+      if (!reason) {
+        return void 0;
+      }
+      if (reason === "retry") {
+        resumeMessages = [...latestSafeBoundaryMessages];
+      }
+      const parkMessages = reason === "yield" ? [...resumeMessages] : continuableMessages(resumeMessages, latestSafeBoundaryMessages);
+      const parkKey = boundaryKey(parkMessages);
+      if (!advancedPastResume && resumedBoundaryKey.length > 0 && parkKey === resumedBoundaryKey) {
+        logWarn("agent.turn.no_progress_fail", {
+          "app.ai.resume_conversation_id": args.conversationId,
+          "app.ai.resume_session_id": args.turnId,
+          "app.ai.resume_slice_id": currentSliceId,
+          "app.ai.resume_reason": reason
         });
-        if (!sessionRecord) {
-          throw new Error(
-            `Failed to persist cooperative yield continuation for conversation=${args.conversationId} turn=${args.turnId}`
-          );
-        }
+        await saveTurnCheckpoint({
+          mode: "failed",
+          ...writeBase(),
+          sliceId: currentSliceId,
+          durationMs: durationMs(),
+          messages: parkMessages,
+          errorMessage: "Turn made no progress: continue parked at the same boundary"
+        });
+        throw new Error(
+          `Turn made no progress for conversation=${args.conversationId} turn=${args.turnId}`
+        );
+      }
+      const usage = ending.currentUsage ?? extractSliceUsage(parkMessages, beforeMessageCount);
+      await args.recordActiveMcpProviders();
+      const record2 = await saveTurnCheckpoint({
+        mode: "paused",
+        reason,
+        ...writeBase(),
+        sliceId: currentSliceId,
+        durationMs: durationMs(),
+        usage,
+        messages: parkMessages,
+        errorMessage: error instanceof Error ? error.message : String(error)
+      });
+      if (!record2) {
+        throw new Error(
+          `Failed to persist continuation for conversation=${args.conversationId} turn=${args.turnId}`
+        );
+      }
+      if (record2.state === "paused") {
         return {
           status: "suspended",
-          resumeVersion: sessionRecord.version,
+          resumeVersion: record2.version,
           ...usage ? { usage } : {}
         };
       }
-      const resumeReason = error instanceof RetryableDeliveryError ? "retry" : timedOut ? "timeout" : void 0;
-      if (resumeReason) {
-        if (resumeReason === "retry") {
-          resumeMessages = [...latestSafeBoundaryMessages];
-        }
-        const usage = ending.currentUsage ?? extractSliceUsage(resumeMessages, beforeMessageCount);
-        await args.recordActiveMcpProviders();
-        const sessionRecord = await persistContinuationSessionRecord({
-          ...sessionRecordBase(),
-          currentSliceId,
-          currentDurationMs: currentDurationMs(),
-          currentUsage: usage,
-          messages: resumeMessages,
-          errorMessage: error instanceof Error ? error.message : String(error),
-          resumeReason
-        });
-        if (!sessionRecord) {
-          throw new Error(
-            `Failed to persist continuation for conversation=${args.conversationId} turn=${args.turnId}`
-          );
-        }
-        if (sessionRecord.state === "awaiting_resume") {
-          return {
-            status: "suspended",
-            resumeVersion: sessionRecord.version,
-            ...usage ? { usage } : {}
-          };
-        }
-        throw new TurnSliceLimitExceededError(botConfig.maxSlicesPerTurn);
-      }
-      return void 0;
+      throw new TurnSliceLimitExceededError(botConfig.maxSlicesPerTurn);
     }
   };
 }
@@ -16482,20 +16794,11 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
     const skillInvocation = parseSkillInvocation(userInput, availableSkills);
     const invokedSkill = skillInvocation ? findSkillByName(skillInvocation.skillName, availableSkills) : null;
     const activeSkills = [];
-    let loadedSkillNamesForResume = [];
-    const syncLoadedSkillNamesForResume = () => {
-      loadedSkillNamesForResume = activeSkills.map((skill) => skill.name);
-    };
     const skillSandbox = new SkillSandbox(availableSkills, activeSkills);
-    const {
-      sessionRecordState,
-      resumedFromSessionRecord,
-      currentSliceId,
-      existingSessionRecord
-    } = await restoreSessionRecord({
-      conversationId,
-      turnId
-    });
+    const checkpoint = await loadTurnCheckpoint({ conversationId, turnId });
+    const resumedFromSessionRecord = checkpoint.resumed;
+    const currentSliceId = checkpoint.sliceId;
+    const existingSessionRecord = checkpoint.record;
     const committedInstructionProvenance = [
       ...existingSessionRecord?.piMessageProvenance ?? [],
       ...(existingSessionRecord?.actors ?? []).map(instructionProvenanceFor),
@@ -16525,15 +16828,12 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       ...routing.destinationVisibility ? { destinationVisibility: routing.destinationVisibility } : {},
       ...routing.dispatch?.id ? { dispatchId: routing.dispatch.id } : {},
       durability,
-      getLoadedSkillNames: () => loadedSkillNamesForResume,
-      getReasoningLevel: () => turnRoute?.reasoningLevel,
-      getModelId: () => activeModelId,
       recordActiveMcpProviders,
       actor,
       runSource,
       conversationId,
       turnId,
-      sessionRecordState,
+      checkpoint,
       startedAtMs: replyStartedAtMs,
       surface
     });
@@ -16565,8 +16865,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       activeSkills,
       invokedSkill,
       priorPiMessages,
-      skillSandbox,
-      syncLoadedSkillNamesForResume
+      skillSandbox
     });
     const explicitSkill = invokedSkill ? activeSkills.find((skill) => skill.name === invokedSkill.name) ?? null : null;
     const { contextContentParts, routerBlocks, userContentParts } = buildPromptInput(input);
@@ -16580,10 +16879,9 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
           botConfig,
           activeModelProfile
         );
-        const resumedReasoningLevel = existingSessionRecord?.reasoningLevel ? parseTurnReasoningLevel(existingSessionRecord.reasoningLevel) : void 0;
         turnRoute = {
           profile: activeModelProfile,
-          reasoningLevel: activeProfileConfig.reasoningLevel ?? resumedReasoningLevel ?? storedTurnRoute.reasoningLevel,
+          reasoningLevel: activeProfileConfig.reasoningLevel ?? storedTurnRoute.reasoningLevel,
           reason: `resumed_handoff:${storedTurnRoute.modelProfile}:${activeModelProfile}`
         };
       } else {
@@ -16793,7 +17091,6 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       state,
       supportsImageInput: () => resolveGatewayModel(activeModelId).input.includes("image"),
       surface,
-      syncLoadedSkillNamesForResume,
       toolCalls,
       userInput
     });
@@ -17134,6 +17431,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
         runResume.setTurnStartMessageIndex(
           existingSessionRecord.turnStartMessageIndex
         );
+        runResume.adoptCommittedBoundary([...agent.state.messages]);
       } else if (promptHistoryMessages.length > 0) {
         agent.state.messages = [...promptHistoryMessages];
       }
@@ -17458,7 +17756,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       throw error.originalError;
     }
     const runError = error instanceof AssistantMessageDeliveryError ? error.originalError : error;
-    if (runError instanceof AuthPausePersistenceError) {
+    if (runError instanceof AuthPausePersistenceError || runError instanceof TurnSliceLimitExceededError) {
       throw runError;
     }
     if (resume && runError instanceof AuthorizationPauseError) {
@@ -17572,8 +17870,8 @@ export {
   deliverResourceEventSubscription,
   sanitizeScheduledTaskPrincipal,
   listThreadReplies,
-  renderSlackLegacyAttachmentText,
-  appendSlackLegacyAttachmentText,
+  renderBlockText,
+  renderAttachmentText,
   latestReportedProgress,
   executeCredentialedEgressRequest,
   createContextCompactor,