@sentry/junior 0.116.1 → 0.118.0

package/dist/{chunk-GDAXWEIJ.js → chunk-6K2QE2UI.js}

@@ -2,6 +2,8 @@ import {
   authorizationId
 } from "./chunk-DIB4GX3G.js";
 import {
+  McpProviderError,
+  McpToolError,
   RetryableDeliveryError,
   actorFromRouting,
   addReactionToMessage,
@@ -12,6 +14,9 @@ import {
   deliverOAuthAuthorization,
   formatProviderLabel,
   getMcpAuthSession,
+  getMcpAwareErrorType,
+  getMcpAwareTelemetryMessage,
+  getMcpProviderErrorAttributes,
   getSlackMessagePermalink,
   hasEgressCredentialHooks,
   issuePluginCredential,
@@ -23,9 +28,10 @@ import {
   slackOutputPolicy,
   startOAuthFlow,
   surfaceFromRouting,
+  toMcpProviderError,
   toolInvocationDestination,
   uploadFilesToConversation
-} from "./chunk-CGXLCMWI.js";
+} from "./chunk-S6R23MFB.js";
 import {
   CooperativeTurnYieldError,
   JUNIOR_THREAD_STATE_TTL_MS,
@@ -67,7 +73,7 @@ import {
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages,
   updateConversationStats
-} from "./chunk-RYFAVWP3.js";
+} from "./chunk-PJPKHGLG.js";
 import {
   parseSandboxEgressAuthRequiredSignal,
   parseSandboxEgressPermissionDeniedSignal,
@@ -78,20 +84,23 @@ import {
   bindSandboxFileSystem,
   buildNonInteractiveShellScript,
   createSandboxSession,
-  getRuntimeDependencyProfileHash,
   getSandboxResources,
   getVercelSandboxCredentials,
+  hash,
   isAlreadyExistsError,
+  isMissingError,
   isSandboxCommandStreamInterruptedError,
   isSandboxMissingError,
   isSandboxUnavailableError,
-  isSnapshotMissingError,
   isSnapshottingError,
-  resolveRuntimeDependencySnapshot,
+  resolve,
   runNonInteractiveCommand,
   throwSandboxOperationError,
   wrapSandboxSetupError
-} from "./chunk-VBMMMVVQ.js";
+} from "./chunk-4LPPH7Y6.js";
+import {
+  incrementStat
+} from "./chunk-L72GDKSN.js";
 import {
   addAgentTurnUsage,
   hasAgentTurnUsage
@@ -100,30 +109,20 @@ import {
   privateTraceResultAttributes
 } from "./chunk-UIE3R5XU.js";
 import {
+  SlackActionError,
   createPluginHookRunner,
+  downloadPrivateSlackFile,
+  getFilePermalink,
   getPluginSystemPromptContributions,
   getPluginTools,
   getPluginUserPromptContributions,
-  getSlackToolContext,
-  resolveChannelCapabilities
-} from "./chunk-ZYHLNTC2.js";
-import {
-  SANDBOX_DATA_ROOT,
-  SANDBOX_SKILLS_ROOT,
-  SANDBOX_WORKSPACE_ROOT,
-  getStateAdapter,
-  sandboxSkillDir,
-  sandboxSkillFile
-} from "./chunk-7CSVG54J.js";
-import {
-  SlackActionError,
-  downloadPrivateSlackFile,
-  getFilePermalink,
   getSlackClient,
+  getSlackToolContext,
   isConversationScopedChannel,
   normalizeSlackConversationId,
+  resolveChannelCapabilities,
   withSlackRetries
-} from "./chunk-FAEALXEH.js";
+} from "./chunk-GT2ZUALJ.js";
 import {
   KNOWN_CONVERSATION_EVENT_TYPES,
   contextProvenance,
@@ -132,11 +131,19 @@ import {
   getConversationStore,
   instructionActors,
   instructionProvenanceFor
-} from "./chunk-BFYVIOTS.js";
+} from "./chunk-KC5EE27Y.js";
 import {
+  SANDBOX_DATA_ROOT,
+  SANDBOX_SKILLS_ROOT,
+  SANDBOX_WORKSPACE_ROOT,
+  getStateAdapter,
+  sandboxSkillDir,
+  sandboxSkillFile,
+  sandboxSkillPathResolution,
   sleep
-} from "./chunk-4ZNGQH7C.js";
+} from "./chunk-3N3FMCKN.js";
 import {
+  ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX,
   COMPACTION_SUMMARY_PREFIX,
   DEFAULT_HANDOFF_MODEL_PROFILE,
   GEN_AI_PROVIDER_NAME,
@@ -165,7 +172,7 @@ import {
   renderCurrentInstruction,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-CY7NXM32.js";
+} from "./chunk-PWRFTDTY.js";
 import {
   canExposeConversationPayload,
   parseSlackThreadId,
@@ -182,15 +189,18 @@ import {
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-DLLW5ITL.js";
+} from "./chunk-7GADTCNS.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-OY2PQQ4P.js";
+} from "./chunk-UXLYAVYL.js";
 import {
   CredentialUnavailableError,
+  OAuthProviderError,
+  fetchWithBoundedOAuthErrorBodies,
+  getOAuthProviderErrorAttributes,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv
-} from "./chunk-XA3VLFPK.js";
+} from "./chunk-3LGCVRBQ.js";
 import {
   credentialUserSubjectId
 } from "./chunk-W3U3YQYI.js";
@@ -214,7 +224,7 @@ import {
   summarizeMessageText,
   withLogContext,
   withSpan
-} from "./chunk-F3SWGSPG.js";
+} from "./chunk-MLZFK4KP.js";
 import {
   parseSlackChannelId,
   parseSlackMessageTs,
@@ -1658,13 +1668,10 @@ function formatSkillEntry(skill) {
   lines.push("  </skill>");
   return lines;
 }
-function formatAvailableSkillsForPrompt(skills, invocation) {
+function formatAvailableSkillsForPrompt(skills) {
   const autoSelectable = skills.filter(
     (s) => s.disableModelInvocation !== true
   );
-  const invokedExplicitOnly = invocation ? skills.filter(
-    (s) => s.disableModelInvocation === true && s.name === invocation.skillName
-  ) : [];
   const sections = [];
   if (autoSelectable.length > 0) {
     const available = [
@@ -1677,17 +1684,6 @@ function formatAvailableSkillsForPrompt(skills, invocation) {
     available.push("</available-skills>");
     sections.push(available.join("\n"));
   }
-  if (invokedExplicitOnly.length > 0) {
-    const userCallable = [
-      "<user-callable-skills>",
-      "The user's current message explicitly references this skill by name. Load it when relevant to the request."
-    ];
-    for (const skill of invokedExplicitOnly) {
-      userCallable.push(...formatSkillEntry(skill));
-    }
-    userCallable.push("</user-callable-skills>");
-    sections.push(userCallable.join("\n"));
-  }
   return sections.length > 0 ? sections.join("\n") : null;
 }
 function formatActiveMcpCatalogsForPrompt(catalogs) {
@@ -1800,7 +1796,8 @@ var TOOL_CALL_STYLE_RULES = [
   "- Keep tool-call explanations separate from final answers; final answers should report results, evidence, or blockers."
 ];
 var SKILL_POLICY_RULES = [
-  "- Only load skills listed in `<available-skills>`, `<user-callable-skills>`, or named by `<explicit-skill-trigger>`. Never guess or invent a skill name.",
+  "- A `<skill>` block in the current user turn is already loaded. Follow its instructions directly and do not call `loadSkill` for that skill.",
+  "- Otherwise, only load skills listed in `<available-skills>`. Never guess or invent a skill name.",
   "- Load one skill at a time. After `loadSkill`, follow the instructions returned by that tool result."
 ];
 var EXECUTION_CONTRACT_RULES = [
@@ -1985,14 +1982,6 @@ function buildContextSection(params) {
       ])
     );
   }
-  if (params.invocation) {
-    blocks.push(
-      renderTag("explicit-skill-trigger", [
-        "Treat this skill as selected. Load it unless the tool says it is unavailable.",
-        `/${escapeXml(params.invocation.skillName)}`
-      ])
-    );
-  }
   const body = blocks.map((block) => block.join("\n")).join("\n\n");
   if (!body) {
     return null;
@@ -2002,8 +1991,7 @@ function buildContextSection(params) {
 function buildCapabilitiesSection(params) {
   const blocks = [];
   const availableSkills = formatAvailableSkillsForPrompt(
-    params.availableSkills,
-    params.invocation
+    params.availableSkills
   );
   if (availableSkills) {
     blocks.push(availableSkills);
@@ -2084,7 +2072,6 @@ function buildTurnContextPrompt(params) {
     includeSessionContext ? buildCapabilitiesSection({
       availableSkills: params.availableSkills,
       activeMcpCatalogs: params.activeMcpCatalogs ?? [],
-      invocation: params.invocation,
       toolGuidance: params.toolGuidance ?? []
     }) : null,
     pluginPromptContributions,
@@ -2092,8 +2079,7 @@ function buildTurnContextPrompt(params) {
       actor: params.actor,
       artifactState: params.artifactState,
       configuration: params.configuration,
-      dispatch: params.dispatch,
-      invocation: params.invocation
+      dispatch: params.dispatch
     }) : null,
     includeSessionContext ? buildRuntimeSection(params.runtime ?? {}) : null
   ].filter((section) => Boolean(section));
@@ -2136,6 +2122,17 @@ function buildUserTurnText(userInput, conversationContext, actor) {
     currentInstruction
   ].join("\n");
 }
+function renderExplicitSkillInstructions(skill) {
+  return [
+    "<skill>",
+    `<name>${escapeXml(skill.name)}</name>`,
+    `<path>${escapeXml(sandboxSkillFile(skill.name))}</path>`,
+    `<working_directory>${escapeXml(sandboxSkillDir(skill.name))}</working_directory>`,
+    `<path_resolution>${escapeXml(sandboxSkillPathResolution(skill.name))}</path_resolution>`,
+    skill.body,
+    "</skill>"
+  ].join("\n");
+}
 function encodeNonImageAttachmentForPrompt(attachment) {
   const base64 = attachment.data.toString("base64");
   const wasTruncated = base64.length > MAX_INLINE_ATTACHMENT_BASE64_CHARS;
@@ -2302,21 +2299,62 @@ function withoutTrailingUncheckpointedUserPrompt(messages, userContentParts) {
 function userPromptContentMatches(storedContent, currentContent) {
   return isDeepStrictEqual(storedContent, currentContent);
 }
+function isUserContentPart(value) {
+  if (typeof value !== "object" || value === null || !("type" in value)) {
+    return false;
+  }
+  if (value.type === "text") {
+    return "text" in value && typeof value.text === "string";
+  }
+  return value.type === "image" && "data" in value && typeof value.data === "string" && "mimeType" in value && typeof value.mimeType === "string";
+}
+function checkpointedPromptContent(args) {
+  if (!args.messages || args.turnStartMessageIndex === void 0 || args.turnStartMessageIndex !== args.messages.length - 1) {
+    return void 0;
+  }
+  const message = args.messages[args.turnStartMessageIndex];
+  if (message?.role !== "user" || !Array.isArray(message.content)) {
+    return void 0;
+  }
+  const durableMessage = stripRuntimeTurnContext([message])[0];
+  if (!userPromptContentMatches(durableMessage?.content, args.userContentParts)) {
+    return void 0;
+  }
+  const content = message.content;
+  if (!content.every(isUserContentPart)) {
+    return void 0;
+  }
+  return content;
+}
 async function assemblePrompt(args) {
   const source = args.routing.source;
   const hasPromptCheckpoint = args.resumedFromSessionRecord && args.existingTurnStartMessageIndex !== void 0;
   const shouldPromptAgent = !args.resumedFromSessionRecord || !hasPromptCheckpoint;
+  const requestContentParts = [
+    ...args.explicitSkill ? [
+      {
+        type: "text",
+        text: renderExplicitSkillInstructions(args.explicitSkill)
+      }
+    ] : [],
+    ...args.userContentParts
+  ];
   const promptHistoryMessages = shouldPromptAgent ? withoutTrailingUncheckpointedUserPrompt(
     args.priorPiMessages,
-    args.userContentParts
+    requestContentParts
   ) : args.existingSessionPiMessages;
-  const needsBootstrapContextForPrompt = shouldPromptAgent && !hasRuntimeTurnContext(promptHistoryMessages);
+  const replayedPromptContent = shouldPromptAgent && !args.resumedFromSessionRecord ? checkpointedPromptContent({
+    messages: args.existingSessionPiMessages,
+    turnStartMessageIndex: args.existingTurnStartMessageIndex,
+    userContentParts: requestContentParts
+  }) : void 0;
+  const needsBootstrapContextForPrompt = shouldPromptAgent && !replayedPromptContent && !hasRuntimeTurnContext(promptHistoryMessages);
   const systemPromptContributions = await getPluginSystemPromptContributions(source);
   const pluginSystemPrompt = buildPluginSystemPromptContributions(
     systemPromptContributions
   );
   const baseInstructions = [buildSystemPrompt({ source }), pluginSystemPrompt].filter((section) => Boolean(section)).join("\n\n");
-  const pluginUserPromptContributions = !shouldPromptAgent ? [] : await getPluginUserPromptContributions({
+  const pluginUserPromptContributions = !shouldPromptAgent || replayedPromptContent ? [] : await getPluginUserPromptContributions({
     context: args.toolRuntimeContext
   });
   const turnContextPrompt = needsBootstrapContextForPrompt || pluginUserPromptContributions.length > 0 ? buildTurnContextPrompt({
@@ -2334,13 +2372,15 @@ async function assemblePrompt(args) {
       destination: args.routing.destination,
       source
     } : void 0,
-    invocation: args.invocation,
     actor: isUserActor(args.currentActor) ? args.currentActor : void 0,
     artifactState: args.artifactState,
     configuration: args.configurationValues
   }) : null;
   const turnContextParts = turnContextPrompt ? [{ type: "text", text: turnContextPrompt }] : [];
-  const promptContentParts = [...turnContextParts, ...args.userContentParts];
+  const promptContentParts = replayedPromptContent ?? [
+    ...turnContextParts,
+    ...requestContentParts
+  ];
   const inputMessages = [
     {
       role: "system",
@@ -2371,7 +2411,10 @@ async function assemblePrompt(args) {
     inputMessagesAttribute,
     promptContentParts,
     promptHistoryMessages,
-    shouldPromptAgent
+    shouldPromptAgent,
+    turnContexts: pluginUserPromptContributions.flatMap(
+      (contribution) => contribution.context ? [contribution.context] : []
+    )
   };
 }
 
@@ -3028,6 +3071,7 @@ import { Sandbox } from "@vercel/sandbox";
 // src/chat/sandbox/skill-sync.ts
 import fs3 from "fs/promises";
 import path3 from "path";
+var DIRECTORY_CREATE_CONCURRENCY = 8;
 function toPosixRelative(base, absolute) {
   return path3.relative(base, absolute).split(path3.sep).join("/");
 }
@@ -3102,6 +3146,16 @@ function collectDirectories(filesToWrite, workspaceRoot) {
     (directory) => directory === workspaceRoot || directory.startsWith(`${workspaceRoot}/`)
   ).sort((a, b) => a.length - b.length);
 }
+function groupDirectoriesByDepth(directories) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const directory of directories) {
+    const depth = directory.split("/").filter(Boolean).length;
+    const group = groups.get(depth) ?? [];
+    group.push(directory);
+    groups.set(depth, group);
+  }
+  return [...groups.entries()].sort(([left], [right]) => left - right).map(([, group]) => group);
+}
 function resolveHostSkillPath(availableSkills, sandboxPath) {
   const normalizedPath = path3.posix.normalize(sandboxPath.trim());
   for (const skill of availableSkills) {
@@ -3171,13 +3225,21 @@ async function syncSkillsToSandbox(params) {
         },
         async () => {
           try {
-            for (const directory of directories) {
-              try {
-                await params.sandbox.mkDir(directory);
-              } catch (error) {
-                if (!isAlreadyExistsError(error)) {
-                  throw error;
-                }
+            for (const directoriesAtDepth of groupDirectoriesByDepth(
+              directories
+            )) {
+              for (let offset = 0; offset < directoriesAtDepth.length; offset += DIRECTORY_CREATE_CONCURRENCY) {
+                await Promise.all(
+                  directoriesAtDepth.slice(offset, offset + DIRECTORY_CREATE_CONCURRENCY).map(async (directory) => {
+                    try {
+                      await params.sandbox.mkDir(directory);
+                    } catch (error) {
+                      if (!isAlreadyExistsError(error)) {
+                        throw error;
+                      }
+                    }
+                  })
+                );
               }
             }
             await params.sandbox.writeFiles(filesToWrite);
@@ -3240,7 +3302,7 @@ function createSandboxRuntime(options) {
   let closed = false;
   const timeoutMs = options.timeoutMs ?? 1e3 * 60 * 30;
   const traceContext = options.traceContext ?? {};
-  const dependencyProfileHash = getRuntimeDependencyProfileHash(SANDBOX_RUNTIME);
+  const dependencyProfileHash = hash(SANDBOX_RUNTIME);
   const resolveCommandEnv = options.commandEnv ?? (async () => ({}));
   const withSandboxSpan = (name, op, attributes, callback) => withSpan(name, op, traceContext, callback, attributes);
   const invalidateSession = (sessionId) => {
@@ -3402,13 +3464,13 @@ function createSandboxRuntime(options) {
         sandboxName
       );
     } catch (error) {
-      if (!isSnapshotMissingError(error)) {
+      if (!isMissingError(error)) {
         throw error;
       }
       setSpanAttributes({
         "app.sandbox.snapshot.rebuild_after_missing": true
       });
-      const rebuiltSnapshot = await resolveRuntimeDependencySnapshot({
+      const rebuiltSnapshot = await resolve({
         runtime,
         timeoutMs,
         forceRebuild: true,
@@ -3439,7 +3501,7 @@ function createSandboxRuntime(options) {
           "app.sandbox.runtime": runtime
         },
         async () => {
-          const snapshot = await resolveRuntimeDependencySnapshot({
+          const snapshot = await resolve({
             runtime,
             timeoutMs
           });
@@ -3774,6 +3836,7 @@ var RIPGREP_EXCLUDED_GLOBS = [
   "!**/.git/**",
   "!**/node_modules/**"
 ];
+var DEFAULT_SEARCH_COMMAND_TIMEOUT_MS = 3e4;
 var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([".git", "node_modules"]);
 function positiveInteger(value) {
   if (typeof value !== "number" || !Number.isFinite(value)) {
@@ -4361,7 +4424,7 @@ function createEditFileTool() {
 // src/chat/tools/sandbox/find-files.ts
 import path5 from "path";
 import { z as z5 } from "zod";
-var DEFAULT_FIND_LIMIT = 1e3;
+var DEFAULT_FIND_LIMIT = 100;
 async function findFiles(params) {
   if (!params.pattern.trim()) {
     throw new Error("pattern is required");
@@ -4372,6 +4435,7 @@ async function findFiles(params) {
     return await findFilesWithRipgrep({
       fs: params.fs,
       limit,
+      onTelemetry: params.onTelemetry,
       path: params.path,
       pattern: params.pattern,
       root,
@@ -4440,25 +4504,45 @@ async function findFilesWithRipgrep(params) {
     throw error;
   }
   const location = getRipgrepSearchLocation(params.root, rootIsDirectory);
-  const args = [
+  const ripgrepArgs = [
     "--files",
     "--null",
     "--hidden",
-    "--sort=path",
     "--glob",
     params.pattern
   ];
   for (const excludedGlob of RIPGREP_EXCLUDED_GLOBS) {
-    args.push("--glob", excludedGlob);
+    ripgrepArgs.push("--glob", excludedGlob);
   }
-  args.push("--", location.target);
+  ripgrepArgs.push("--", location.target);
   const result = await params.runCommand({
-    cmd: "rg",
-    args,
-    cwd: location.cwd
+    cmd: "bash",
+    args: [
+      "-c",
+      [
+        `rg "$@" | head -z -n ${params.limit + 1}`,
+        'statuses=("${PIPESTATUS[@]}")',
+        "if (( statuses[1] != 0 )); then",
+        '  exit "${statuses[1]}"',
+        "fi",
+        "if (( statuses[0] == 0 || statuses[0] == 1 || statuses[0] == 141 )); then",
+        "  exit 0",
+        "fi",
+        'exit "${statuses[0]}"'
+      ].join("\n"),
+      "find-files",
+      ...ripgrepArgs
+    ],
+    cwd: location.cwd,
+    timeoutMs: DEFAULT_SEARCH_COMMAND_TIMEOUT_MS
   });
-  if (result.exitCode !== 0 && result.exitCode !== 1) {
+  if (result.exitCode !== 0) {
     const detail = result.stderr.trim() || result.stdout.trim() || "command failed";
+    if (/error parsing glob|invalid glob/i.test(detail)) {
+      throw new ToolInputError(`Invalid glob pattern: ${params.pattern}`, {
+        cause: new Error(detail)
+      });
+    }
     throw new Error(`ripgrep file search failed: ${detail}`);
   }
   const allPaths = result.stdout.split("\0").filter(Boolean).map((filePath) => {
@@ -4482,7 +4566,7 @@ async function findFilesWithRipgrep(params) {
   const text = notices.length > 0 ? `${bounded.content}
 
 [${notices.join(" ")}]` : bounded.content;
-  return makeStructuredToolResult(
+  const response = makeStructuredToolResult(
     {
       ok: true,
       status: "success",
@@ -4499,6 +4583,19 @@ async function findFilesWithRipgrep(params) {
     },
     { content: [{ type: "text", text }] }
   );
+  params.onTelemetry?.({
+    emittedLineCount: relativePaths.length,
+    limit: params.limit,
+    limitReached,
+    parsedRecordCount: allPaths.length,
+    rawOutputBytes: Buffer.byteLength(result.stdout, "utf8"),
+    resultBytes: response.content.reduce(
+      (total, item) => total + (item.type === "text" ? Buffer.byteLength(item.text, "utf8") : 0),
+      0
+    ),
+    resultCount: relativePaths.length
+  });
+  return response;
 }
 function createFindFilesTool() {
   return zodTool({
@@ -4511,7 +4608,7 @@ function createFindFilesTool() {
       path: z5.string().min(1).describe(
         "Directory or file path in the sandbox workspace. Defaults to the workspace root."
       ).optional(),
-      limit: z5.coerce.number().int().min(1).describe("Maximum number of file paths to return. Defaults to 1000.").optional()
+      limit: z5.coerce.number().int().min(1).describe("Maximum number of file paths to return. Defaults to 100.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async () => {
@@ -4564,6 +4661,7 @@ async function grepFiles(params) {
       ignoreCase: params.ignoreCase,
       limit,
       literal: params.literal,
+      onTelemetry: params.onTelemetry,
       path: params.path,
       pattern: params.pattern,
       root,
@@ -4711,7 +4809,13 @@ async function grepFilesWithRipgrep(params) {
     throw error;
   }
   const location = getRipgrepSearchLocation(params.root, rootIsDirectory);
-  const args = ["--json", "--line-number", "--hidden", "--sort=path"];
+  const args = [
+    "--json",
+    "--line-number",
+    "--hidden",
+    "--max-count",
+    String(params.limit + 1)
+  ];
   if (params.ignoreCase) {
     args.push("--ignore-case");
   }
@@ -4731,7 +4835,8 @@ async function grepFilesWithRipgrep(params) {
   const result = await params.runCommand({
     cmd: "rg",
     args,
-    cwd: location.cwd
+    cwd: location.cwd,
+    timeoutMs: DEFAULT_SEARCH_COMMAND_TIMEOUT_MS
   });
   if (result.exitCode !== 0 && result.exitCode !== 1) {
     const detail = result.stderr.trim() || result.stdout.trim() || "command failed";
@@ -4745,6 +4850,7 @@ async function grepFilesWithRipgrep(params) {
   const recordsByPath = /* @__PURE__ */ new Map();
   const pathOrder = [];
   let totalMatches = 0;
+  let parsedRecordCount = 0;
   for (const rawLine of normalizeToLf(result.stdout).split("\n")) {
     if (!rawLine) {
       continue;
@@ -4755,6 +4861,7 @@ async function grepFilesWithRipgrep(params) {
     } catch (error) {
       throw new Error("ripgrep returned invalid JSON output", { cause: error });
     }
+    parsedRecordCount += 1;
     if (record.type !== "match" && record.type !== "context") {
       continue;
     }
@@ -4836,7 +4943,7 @@ async function grepFilesWithRipgrep(params) {
   if (bounded.truncated) {
     notices.push(`${MAX_TEXT_CHARS} character output limit reached.`);
   }
-  return makeStructuredToolResult({
+  const response = makeStructuredToolResult({
     ok: true,
     status: "success",
     target: params.path ?? ".",
@@ -4855,6 +4962,19 @@ async function grepFilesWithRipgrep(params) {
     ...matchLimitReached ? { match_limit_reached: params.limit } : {},
     ...lineTruncated ? { line_truncated: true } : {}
   });
+  params.onTelemetry?.({
+    emittedLineCount: output.length,
+    limit: params.limit,
+    limitReached: matchLimitReached,
+    parsedRecordCount,
+    rawOutputBytes: Buffer.byteLength(result.stdout, "utf8"),
+    resultBytes: response.content.reduce(
+      (total, item) => total + (item.type === "text" ? Buffer.byteLength(item.text, "utf8") : 0),
+      0
+    ),
+    resultCount: matchCount
+  });
+  return response;
 }
 function createGrepTool() {
   return zodTool({
@@ -5194,11 +5314,12 @@ function createSandbox(options) {
     onSandboxPrepare: options.prepare,
     onSandboxRefChanged: options.onSandboxRefChanged
   });
-  const createToolCallContext = (signal) => {
+  const createToolCallContext = (signal, setToolCallSpanAttributes) => {
     let fileSystemPromise;
     let commandRunnerPromise;
     return {
       signal,
+      setToolCallSpanAttributes,
       fileSystem() {
         signal?.throwIfAborted();
         return fileSystemPromise ??= runtime.tools().then(({ fs: fs5 }) => {
@@ -5219,10 +5340,31 @@ function createSandbox(options) {
     };
   };
   const withSandboxSpan = (name, op, attributes, callback) => withSpan(name, op, traceContext, callback, attributes);
-  const withSandboxToolSpan = (name, op, attributes, callback) => withSandboxSpan(name, op, attributes, async () => {
+  const withSandboxToolSpan = (name, op, attributes, callback) => withSandboxSpan(name, op, attributes, async (setSpanAttributes2) => {
     await runtime.refreshNetworkPolicy(getTracePropagationHeaders());
-    return await callback();
+    return await callback(setSpanAttributes2);
   });
+  const searchTelemetryAttributes = (telemetry) => ({
+    "app.sandbox.search.raw_output_bytes": telemetry.rawOutputBytes,
+    "app.sandbox.search.parsed_records": telemetry.parsedRecordCount,
+    "app.sandbox.search.result_count": telemetry.resultCount,
+    "app.sandbox.search.emitted_lines": telemetry.emittedLineCount,
+    "app.sandbox.search.result_bytes": telemetry.resultBytes,
+    "app.sandbox.search.limit": telemetry.limit,
+    "app.sandbox.search.limit_reached": telemetry.limitReached
+  });
+  const recordSearchTelemetry = (telemetry, setSearchSpanAttributes, setToolCallSpanAttributes) => {
+    const attributes = searchTelemetryAttributes(telemetry);
+    for (const setAttributes of [
+      setSearchSpanAttributes,
+      setToolCallSpanAttributes
+    ]) {
+      try {
+        setAttributes?.(attributes);
+      } catch {
+      }
+    }
+  };
   const logSandboxBootRequest = (trigger, details = {}) => {
     if (runtime.sandboxRef()) {
       return;
@@ -5467,10 +5609,15 @@ function createSandbox(options) {
       {
         "app.sandbox.pattern.length": pattern.length
       },
-      async () => {
+      async (setSearchSpanAttributes) => {
         const response = await grepFiles({
           fs: fileSystem,
           runCommand: await context.commandRunner(),
+          onTelemetry: (telemetry) => recordSearchTelemetry(
+            telemetry,
+            setSearchSpanAttributes,
+            context.setToolCallSpanAttributes
+          ),
           pattern,
           ...typeof rawInput.path === "string" ? { path: rawInput.path } : {},
           ...typeof rawInput.glob === "string" ? { glob: rawInput.glob } : {},
@@ -5499,10 +5646,15 @@ function createSandbox(options) {
       {
         "app.sandbox.pattern.length": pattern.length
       },
-      async () => {
+      async (setSearchSpanAttributes) => {
         const response = await findFiles({
           fs: fileSystem,
           runCommand: await context.commandRunner(),
+          onTelemetry: (telemetry) => recordSearchTelemetry(
+            telemetry,
+            setSearchSpanAttributes,
+            context.setToolCallSpanAttributes
+          ),
           pattern,
           ...typeof rawInput.path === "string" ? { path: rawInput.path } : {},
           ...limit ? { limit } : {}
@@ -5535,7 +5687,10 @@ function createSandbox(options) {
   };
   const execute = async (params) => {
     const rawInput = params.input ?? {};
-    const context = createToolCallContext(params.signal);
+    const context = createToolCallContext(
+      params.signal,
+      params.setToolCallSpanAttributes
+    );
     const bashCommand2 = params.toolName === "bash" ? String(rawInput.command ?? "").trim() : void 0;
     if (params.toolName === "bash") {
       if (!bashCommand2) {
@@ -5846,6 +6001,7 @@ function createAgentSandbox(options) {
 }
 
 // src/chat/mcp/client.ts
+import { AsyncLocalStorage } from "async_hooks";
 import { Client } from "@modelcontextprotocol/sdk/client";
 import {
   UnauthorizedError
@@ -5887,18 +6043,25 @@ var McpAuthorizationRequiredError = class extends Error {
     this.provider = provider;
   }
 };
+function isMissingSessionError(error) {
+  return error instanceof StreamableHTTPError && (error.code === 404 || /Session not found/i.test(error.message));
+}
 var PluginMcpClient = class {
   constructor(plugin, options = {}) {
     this.plugin = plugin;
     this.options = options;
+    const url = plugin.manifest.mcp?.url;
+    this.resourceHost = url ? new URL(url).hostname : void 0;
   }
   plugin;
   options;
   client;
   clientPromise;
   lastAttemptedTransportSessionId;
+  providerStatusStore = new AsyncLocalStorage();
   transport;
   listedTools;
+  resourceHost;
   async listTools() {
     if (this.listedTools) {
       return [...this.listedTools];
@@ -5910,7 +6073,8 @@ var PluginMcpClient = class {
       let cursor;
       do {
         const result = await this.wrapAuth(
-          client.listTools(cursor ? { cursor } : void 0)
+          () => client.listTools(cursor ? { cursor } : void 0),
+          "list_tools"
         );
         await this.syncTransportSessionId();
         for (const tool of result.tools) {
@@ -5943,10 +6107,11 @@ var PluginMcpClient = class {
         });
       }
       const result = await this.wrapAuth(
-        client.callTool({
+        () => client.callTool({
           name,
           arguments: args ?? {}
-        })
+        }),
+        "call_tool"
       );
       await this.syncTransportSessionId();
       return result;
@@ -5964,7 +6129,7 @@ var PluginMcpClient = class {
         throw error;
       }
       await this.clearStoredTransportSessionId();
-      await this.disposeClient();
+      await this.cleanupClientAfterFailure();
       return await operation();
     }
   }
@@ -6000,7 +6165,12 @@ var PluginMcpClient = class {
     this.lastAttemptedTransportSessionId = sessionId;
     const transport = new StreamableHTTPClientTransport(new URL(mcp.url), {
       ...Object.keys(requestInit).length > 0 ? { requestInit } : {},
-      ...this.options.fetch ? { fetch: this.options.fetch } : {},
+      fetch: fetchWithBoundedOAuthErrorBodies(this.options.fetch, (status) => {
+        const store = this.providerStatusStore.getStore();
+        if (store) {
+          store.status = status;
+        }
+      }),
       ...this.options.authProvider ? { authProvider: this.options.authProvider } : {},
       ...sessionId ? { sessionId } : {}
     });
@@ -6009,48 +6179,79 @@ var PluginMcpClient = class {
     });
     this.transport = transport;
     try {
-      await this.wrapAuth(client.connect(transport));
+      await this.wrapAuth(() => client.connect(transport), "connect");
       this.client = client;
       await this.syncTransportSessionId();
       return client;
     } catch (error) {
       await this.syncTransportSessionId();
-      await this.disposeClient();
+      await this.cleanupClientAfterFailure();
       throw error;
     }
   }
-  async wrapAuth(promise) {
-    try {
-      return await promise;
-    } catch (error) {
-      if (error instanceof McpAuthorizationRequiredError) {
-        throw error;
-      }
-      if (error instanceof UnauthorizedError) {
-        throw new McpAuthorizationRequiredError(
-          this.plugin.manifest.name,
-          `MCP authorization required for plugin "${this.plugin.manifest.name}"`
-        );
+  async wrapAuth(operation, phase) {
+    const store = {};
+    return await this.providerStatusStore.run(store, async () => {
+      try {
+        return await operation();
+      } catch (error) {
+        if (error instanceof McpAuthorizationRequiredError) {
+          throw error;
+        }
+        if (error instanceof UnauthorizedError) {
+          throw new McpAuthorizationRequiredError(
+            this.plugin.manifest.name,
+            `MCP authorization required for plugin "${this.plugin.manifest.name}"`
+          );
+        }
+        throw toMcpProviderError(error, {
+          phase,
+          provider: this.plugin.manifest.name,
+          missingSession: isMissingSessionError(error) || void 0,
+          resourceHost: this.resourceHost,
+          status: store.status
+        });
       }
-      throw error;
-    }
+    });
   }
   async shouldResetMissingSession(error) {
-    if (!(error instanceof StreamableHTTPError && (error.code === 404 || /Session not found/i.test(error.message)))) {
+    if (!(error instanceof McpProviderError && error.missingSession || isMissingSessionError(error))) {
       return false;
     }
     return Boolean(
       this.transport?.sessionId ?? this.lastAttemptedTransportSessionId ?? await this.getStoredTransportSessionId()
     );
   }
-  async disposeClient() {
+  resetClientState() {
     const transport = this.transport;
     this.listedTools = void 0;
     this.transport = void 0;
     this.client = void 0;
     this.clientPromise = void 0;
-    if (transport) {
+    return transport;
+  }
+  async cleanupClientAfterFailure() {
+    const transport = this.resetClientState();
+    if (!transport) {
+      return;
+    }
+    try {
       await transport.close();
+    } catch {
+    }
+  }
+  async disposeClient() {
+    const transport = this.resetClientState();
+    if (transport) {
+      try {
+        await transport.close();
+      } catch (error) {
+        throw toMcpProviderError(error, {
+          phase: "close",
+          provider: this.plugin.manifest.name,
+          resourceHost: this.resourceHost
+        });
+      }
     }
   }
   async getStoredTransportSessionId() {
@@ -6073,29 +6274,6 @@ var PluginMcpClient = class {
   }
 };
 
-// src/chat/mcp/errors.ts
-var McpToolError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "McpToolError";
-  }
-};
-function getMcpAwareErrorType(error, fallback) {
-  if (error instanceof McpToolError) {
-    return "tool_error";
-  }
-  return error instanceof Error ? error.name : fallback;
-}
-function getMcpAwareErrorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function getMcpAwareTelemetryMessage(error, privacy) {
-  if (privacy === "private" && error instanceof McpToolError) {
-    return "MCP tool call failed";
-  }
-  return getMcpAwareErrorMessage(error);
-}
-
 // src/chat/mcp/tool-manager.ts
 var MAX_TOOL_RESULT_TOKENS = 1e4;
 var MAX_TOOL_RESULT_BYTES = 32 * 1024;
@@ -6469,6 +6647,7 @@ var McpToolManager = class {
               }
               const errorAttributes = {
                 ...baseAttributes,
+                ...getMcpProviderErrorAttributes(error),
                 "error.type": getMcpAwareErrorType(error, "mcp_tool_error"),
                 "exception.message": getMcpAwareTelemetryMessage(
                   error,
@@ -6840,7 +7019,7 @@ async function loadSkillFromHost(availableSkills, skillName) {
     skill_dir: skillDir,
     working_directory: skillDir,
     location: skillFilePath,
-    path_resolution: `Resolve relative paths in this skill against ${skillDir}. For bash commands from this skill, cd to ${skillDir} first or use absolute paths.`,
+    path_resolution: sandboxSkillPathResolution(skill.name),
     instructions: loaded.body
   };
 }
@@ -7207,13 +7386,77 @@ function createSearchMcpToolsTool(mcpToolManager) {
   });
 }
 
-// src/chat/tools/runtime/report-progress.ts
+// src/chat/tools/sandbox/view-image.ts
 import { z as z15 } from "zod";
+var MAX_VIEW_IMAGE_BYTES = 5 * 1024 * 1024;
+var viewImageInputSchema = z15.object({
+  path: z15.string().min(1).describe("Path to an image file in the sandbox workspace.")
+}).strict();
+function detectImageMimeType(data) {
+  if (data.length >= 8 && data.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+    return "image/png";
+  }
+  if (data.length >= 3 && data[0] === 255 && data[1] === 216 && data[2] === 255) {
+    return "image/jpeg";
+  }
+  if (data.length >= 6 && (data.subarray(0, 6).toString("ascii") === "GIF87a" || data.subarray(0, 6).toString("ascii") === "GIF89a")) {
+    return "image/gif";
+  }
+  if (data.length >= 12 && data.subarray(0, 4).toString("ascii") === "RIFF" && data.subarray(8, 12).toString("ascii") === "WEBP") {
+    return "image/webp";
+  }
+  return void 0;
+}
+function createViewImageTool(sandbox, supportsImageInput, deps = {}) {
+  return zodTool({
+    description: "View an image file from the sandbox workspace when visual inspection is needed. Supports PNG, JPEG, GIF, and WebP images up to 5 MB.",
+    exposure: "direct",
+    inputSchema: viewImageInputSchema,
+    async execute({ path: path9 }) {
+      if (!supportsImageInput()) {
+        throw new ToolInputError(
+          "viewImage is unavailable because the current model does not support image inputs"
+        );
+      }
+      const targetPath = normalizeSandboxPath(path9);
+      const data = deps.readFile ? await deps.readFile(targetPath) : await sandbox.readFileToBuffer({ path: targetPath });
+      if (!data) {
+        throw new SandboxFileNotFoundError(targetPath);
+      }
+      if (data.byteLength === 0) {
+        throw new ToolInputError(`image file is empty: ${targetPath}`);
+      }
+      if (data.byteLength > MAX_VIEW_IMAGE_BYTES) {
+        throw new ToolInputError(
+          `image exceeds ${MAX_VIEW_IMAGE_BYTES} bytes: ${targetPath} (${data.byteLength} bytes)`
+        );
+      }
+      const mimeType = detectImageMimeType(data);
+      if (!mimeType) {
+        throw new ToolInputError(
+          `unsupported image format: ${targetPath}; use PNG, JPEG, GIF, or WebP`
+        );
+      }
+      return {
+        content: [
+          {
+            type: "image",
+            data: data.toString("base64"),
+            mimeType
+          }
+        ]
+      };
+    }
+  });
+}
+
+// src/chat/tools/runtime/report-progress.ts
+import { z as z16 } from "zod";
 function createReportProgressTool() {
   return zodTool({
     description: "Update the user-visible assistant loading message with a short progress phase. For every non-trivial turn, call this early with the initial major work phase, then call it again only when the major phase meaningfully changes. Messages must be written in sentence case with a present-participle verb (e.g. 'Searching docs', 'Reviewing results', 'Running checks'). Skip trivial direct answers, generic filler, and minor substeps.",
-    inputSchema: z15.object({
-      message: z15.string().min(1).describe("Short user-facing progress message.")
+    inputSchema: z16.object({
+      message: z16.string().min(1).describe("Short user-facing progress message.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async () => ({
@@ -7224,34 +7467,34 @@ function createReportProgressTool() {
 }
 
 // src/chat/tools/resource-events.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 
 // src/chat/resource-events/store.ts
 import { createHash } from "crypto";
 import { destinationSchema } from "@sentry/junior-plugin-api";
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var RESOURCE_EVENT_PREFIX = "junior:resource_event_subscription";
 var INDEX_LOCK_TTL_MS = 1e4;
 var SUBSCRIPTION_LOCK_TTL_MS = 1e4;
 var SUBSCRIPTION_LOCK_WAIT_MS = 1e4;
 var SUBSCRIPTION_LOCK_RETRY_MS = 25;
 var SUBSCRIPTION_LOCK_HEARTBEAT_MS = 3e3;
-var subscriptionStatusSchema = z16.enum(["active", "cancelled", "completed"]);
-var subscriptionIdIndexSchema = z16.array(z16.string().min(1));
-var subscriptionSchema = z16.object({
-  conversationId: z16.string().min(1),
-  createdAtMs: z16.number().finite(),
+var subscriptionStatusSchema = z17.enum(["active", "cancelled", "completed"]);
+var subscriptionIdIndexSchema = z17.array(z17.string().min(1));
+var subscriptionSchema = z17.object({
+  conversationId: z17.string().min(1),
+  createdAtMs: z17.number().finite(),
   destination: destinationSchema,
-  events: z16.array(z16.string().min(1)).min(1),
-  expiresAtMs: z16.number().finite(),
-  id: z16.string().min(1),
-  intent: z16.string().min(1),
-  label: z16.string().min(1),
-  provider: z16.string().min(1),
-  resourceRef: z16.string().min(1),
-  resourceType: z16.string().min(1),
+  events: z17.array(z17.string().min(1)).min(1),
+  expiresAtMs: z17.number().finite(),
+  id: z17.string().min(1),
+  intent: z17.string().min(1),
+  label: z17.string().min(1),
+  provider: z17.string().min(1),
+  resourceRef: z17.string().min(1),
+  resourceType: z17.string().min(1),
   status: subscriptionStatusSchema,
-  updatedAtMs: z16.number().finite()
+  updatedAtMs: z17.number().finite()
 }).strict();
 function digest(value) {
   return createHash("sha256").update(value).digest("hex").slice(0, 32);
@@ -7272,8 +7515,8 @@ function indexLockKey(key) {
   return `${key}:lock`;
 }
 async function sleep2(ms) {
-  await new Promise((resolve) => {
-    const timer = setTimeout(resolve, ms);
+  await new Promise((resolve2) => {
+    const timer = setTimeout(resolve2, ms);
     timer.unref?.();
   });
 }
@@ -7607,18 +7850,18 @@ var RESOURCE_WATCH_TOOL_SOURCE = {
   id: "resource-watches",
   description: "Inspect or stop resource watches for the current conversation."
 };
-var subscribeInputSchema = z17.object({
-  resourceRef: z17.string().describe("Opaque resource ref copied from a subscribable tool result."),
-  provider: z17.string().describe("Provider that owns the resource ref."),
-  resourceType: z17.string().describe("Provider-defined resource type from the subscribable hint."),
-  label: z17.string().describe("Human-readable resource label from the subscribable hint."),
-  events: z17.array(z17.string()).min(1).describe(
+var subscribeInputSchema = z18.object({
+  resourceRef: z18.string().describe("Opaque resource ref copied from a subscribable tool result."),
+  provider: z18.string().describe("Provider that owns the resource ref."),
+  resourceType: z18.string().describe("Provider-defined resource type from the subscribable hint."),
+  label: z18.string().describe("Human-readable resource label from the subscribable hint."),
+  events: z18.array(z18.string()).min(1).describe(
     "High-signal event names to deliver to this conversation when they occur."
   ),
-  intent: z17.string().describe(
+  intent: z18.string().describe(
     "Concise reason this conversation wants these events, used when an event arrives."
   ),
-  ttlMs: z17.coerce.number().describe(
+  ttlMs: z18.coerce.number().describe(
     "How long to keep the subscription active. Defaults to 14 days and is capped at 30 days."
   ).optional()
 });
@@ -7711,7 +7954,7 @@ function createListResourceEventSubscriptionsTool(context) {
     description: "List active resource event subscriptions for the current conversation.",
     exposure: "deferred",
     source: RESOURCE_WATCH_TOOL_SOURCE,
-    inputSchema: z17.object({}),
+    inputSchema: z18.object({}),
     outputSchema: juniorToolResultSchema,
     async execute() {
       const conversationId = requireConversationContext(context);
@@ -7744,7 +7987,7 @@ function createStopWatchingResourcesTool(context) {
     description: "Stop every resource watch for the current conversation. Infer the user's intent from context instead of requiring a special command, and call this tool before confirming that watching stopped.",
     exposure: "deferred",
     source: RESOURCE_WATCH_TOOL_SOURCE,
-    inputSchema: z17.object({}),
+    inputSchema: z18.object({}),
     outputSchema: juniorToolResultSchema,
     async execute() {
       const conversationId = requireConversationContext(context);
@@ -7851,11 +8094,11 @@ async function listThreadReplies(input) {
 }
 
 // src/chat/slack/timestamp-param.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 function slackTimestampParam(description) {
-  return z18.preprocess(
+  return z19.preprocess(
     (value) => typeof value === "number" && Number.isFinite(value) ? String(value) : value,
-    z18.string().min(1)
+    z19.string().min(1)
   ).describe(description);
 }
 function optionalSlackTimestampParam(description) {
@@ -7886,10 +8129,10 @@ function parseRequiredSlackTimestampParam(field, value) {
 }
 
 // src/chat/slack/tools/channel-list-messages.ts
-import { z as z19 } from "zod";
-var booleanInput2 = (description) => z19.preprocess(
+import { z as z20 } from "zod";
+var booleanInput2 = (description) => z20.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z19.boolean()
+  z20.boolean()
 ).describe(description);
 function normalizeRangeTimestamp(field, value, targetChannelId) {
   if (value === void 0) {
@@ -7916,9 +8159,9 @@ 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: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z19.object({
-      limit: z19.coerce.number().int().min(1).max(1e3).describe("Maximum number of messages to return across pages.").optional(),
-      cursor: z19.string().min(1).describe("Optional cursor to continue from a prior call.").optional(),
+    inputSchema: z20.object({
+      limit: z20.coerce.number().int().min(1).max(1e3).describe("Maximum number of messages to return across pages.").optional(),
+      cursor: z20.string().min(1).describe("Optional cursor to continue from a prior call.").optional(),
       oldest: optionalSlackTimestampParam(
         "Optional oldest message timestamp (Slack ts) for range filtering."
       ),
@@ -7928,7 +8171,7 @@ function createSlackChannelListMessagesTool(context) {
       inclusive: booleanInput2(
         "Whether oldest/latest bounds should be inclusive."
       ).optional(),
-      max_pages: z19.coerce.number().int().min(1).max(10).describe("Maximum number of API pages to traverse in a single call.").optional()
+      max_pages: z20.coerce.number().int().min(1).max(10).describe("Maximum number of API pages to traverse in a single call.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({
@@ -8002,20 +8245,20 @@ function createSlackChannelListMessagesTool(context) {
 }
 
 // src/chat/slack/tools/conversation-search.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var DEFAULT_LIMIT = 5;
 var conversationSearchOutputSchema = juniorToolResultSchema.extend({
-  query: z20.string(),
-  count: z20.number().int().nonnegative(),
-  threads: z20.array(
-    z20.object({
-      conversation_id: z20.string().min(1),
-      thread_ts: z20.string().min(1),
-      message_id: z20.string().min(1),
-      message_role: z20.enum(["assistant", "user"]),
-      message_timestamp: z20.string().datetime(),
-      excerpt: z20.string(),
-      permalink: z20.string().url().optional()
+  query: z21.string(),
+  count: z21.number().int().nonnegative(),
+  threads: z21.array(
+    z21.object({
+      conversation_id: z21.string().min(1),
+      thread_ts: z21.string().min(1),
+      message_id: z21.string().min(1),
+      message_role: z21.enum(["assistant", "user"]),
+      message_timestamp: z21.string().datetime(),
+      excerpt: z21.string(),
+      permalink: z21.string().url().optional()
     }).strict()
   )
 });
@@ -8028,9 +8271,9 @@ function createSlackConversationSearchTool(scope, currentConversationId, deps =
       description: "Search retained public Junior conversation threads in the current Slack workspace."
     },
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z20.object({
-      query: z20.string().trim().min(1).max(200).describe("Words or a short phrase to find in prior conversations."),
-      limit: z20.number().int().min(1).max(10).describe("Maximum number of prior conversation threads to return.").nullable().optional()
+    inputSchema: z21.object({
+      query: z21.string().trim().min(1).max(200).describe("Words or a short phrase to find in prior conversations."),
+      limit: z21.number().int().min(1).max(10).describe("Maximum number of prior conversation threads to return.").nullable().optional()
     }),
     outputSchema: conversationSearchOutputSchema,
     execute: async ({ query, limit }) => {
@@ -8077,27 +8320,27 @@ function createSlackConversationSearchTool(scope, currentConversationId, deps =
 }
 
 // src/chat/slack/tools/public-search.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var DEFAULT_LIMIT2 = 10;
-var optionalTimestampSchema = z21.preprocess(
+var optionalTimestampSchema = z22.preprocess(
   (value) => typeof value === "string" && value.trim() === "" ? void 0 : value,
-  z21.coerce.number().int().nonnegative().describe("Optional Unix timestamp bound.").optional()
+  z22.coerce.number().int().nonnegative().describe("Optional Unix timestamp bound.").optional()
 );
-var searchMessageSchema = z21.object({
-  author_name: z21.string().optional(),
-  author_user_id: z21.string().optional(),
-  channel_id: z21.string().min(1),
-  channel_name: z21.string().optional(),
-  message_ts: z21.string().min(1),
-  content: z21.string(),
-  is_author_bot: z21.boolean().optional(),
-  permalink: z21.string().url()
+var searchMessageSchema = z22.object({
+  author_name: z22.string().optional(),
+  author_user_id: z22.string().optional(),
+  channel_id: z22.string().min(1),
+  channel_name: z22.string().optional(),
+  message_ts: z22.string().min(1),
+  content: z22.string(),
+  is_author_bot: z22.boolean().optional(),
+  permalink: z22.string().url()
 });
 var publicSearchOutputSchema = juniorToolResultSchema.extend({
-  query: z21.string(),
-  count: z21.number().int().nonnegative(),
-  messages: z21.array(searchMessageSchema),
-  next_cursor: z21.string().optional()
+  query: z22.string(),
+  count: z22.number().int().nonnegative(),
+  messages: z22.array(searchMessageSchema),
+  next_cursor: z22.string().optional()
 });
 function normalizeMessage(value) {
   const parsed = searchMessageSchema.safeParse(value);
@@ -8119,8 +8362,8 @@ 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.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z21.object({
-      query: z21.string().trim().min(1).max(500).describe(
+    inputSchema: z22.object({
+      query: z22.string().trim().min(1).max(500).describe(
         "A focused Slack search query, including Slack search filters when useful."
       ),
       after: optionalTimestampSchema.describe(
@@ -8129,10 +8372,10 @@ function createSlackPublicSearchTool(actionToken) {
       before: optionalTimestampSchema.describe(
         "Optional Unix timestamp upper bound."
       ),
-      cursor: z21.string().min(1).describe("Cursor for the next result page.").optional(),
-      limit: z21.coerce.number().int().min(1).max(20).describe("Maximum results to return; Slack allows at most 20.").optional(),
-      sort: z21.enum(["score", "timestamp"]).describe("Rank by relevance or timestamp.").optional(),
-      sort_dir: z21.enum(["asc", "desc"]).describe("Sort direction.").optional()
+      cursor: z22.string().min(1).describe("Cursor for the next result page.").optional(),
+      limit: z22.coerce.number().int().min(1).max(20).describe("Maximum results to return; Slack allows at most 20.").optional(),
+      sort: z22.enum(["score", "timestamp"]).describe("Rank by relevance or timestamp.").optional(),
+      sort_dir: z22.enum(["asc", "desc"]).describe("Sort direction.").optional()
     }),
     outputSchema: publicSearchOutputSchema,
     execute: async ({
@@ -8198,7 +8441,7 @@ function createSlackPublicSearchTool(actionToken) {
 }
 
 // src/chat/slack/tools/message-add-reaction.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 
 // src/chat/tools/idempotency.ts
 function stableSerialize(value) {
@@ -8222,8 +8465,8 @@ function createOperationKey(toolName, input) {
 function createSlackMessageAddReactionTool(context, state) {
   return zodTool({
     description: "Add an emoji reaction to the current inbound Slack message. Use when the user asks for a reaction on the current message without another target. 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: z22.object({
-      emoji: z22.string().min(1).max(64).describe(
+    inputSchema: z23.object({
+      emoji: z23.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."
       )
     }),
@@ -8274,18 +8517,18 @@ function createSlackMessageAddReactionTool(context, state) {
 
 // src/chat/slack/tools/send-files.ts
 import { createHash as createHash2 } from "crypto";
-import { z as z23 } from "zod";
-var sendFilesDataSchema = z23.object({
-  channel_id: z23.string().min(1),
-  deduplicated: z23.boolean().optional(),
-  file_count: z23.number().int().nonnegative(),
-  file_ids: z23.array(z23.string().min(1)).optional(),
-  thread_ts: z23.string().min(1)
+import { z as z24 } from "zod";
+var sendFilesDataSchema = z24.object({
+  channel_id: z24.string().min(1),
+  deduplicated: z24.boolean().optional(),
+  file_count: z24.number().int().nonnegative(),
+  file_ids: z24.array(z24.string().min(1)).optional(),
+  thread_ts: z24.string().min(1)
 });
 var sendFilesResultSchema = juniorToolResultSchema.extend({
-  ok: z23.literal(true),
-  status: z23.literal("success"),
-  target: z23.string().min(1),
+  ok: z24.literal(true),
+  status: z24.literal("success"),
+  target: z24.string().min(1),
   data: sendFilesDataSchema
 });
 function normalizeFiles(files) {
@@ -8310,8 +8553,8 @@ function fileOperationInput(files) {
 function createSendFilesTool(context, state, materializeFile) {
   return zodTool({
     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: z23.object({
-      files: z23.array(sandboxFileReferenceSchema).min(1).describe(
+    inputSchema: z24.object({
+      files: z24.array(sandboxFileReferenceSchema).min(1).describe(
         "One or more existing sandbox files. Objects returned by imageGenerate or webFetch can be passed unchanged."
       )
     }),
@@ -8615,13 +8858,13 @@ function storedCanvasUrl(state, canvasId) {
 }
 
 // src/chat/slack/tools/canvas/create.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 function createSlackCanvasCreateTool(context, state) {
   return zodTool({
     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: z24.object({
-      title: z24.string().min(1).max(160).describe("Canvas title."),
-      markdown: z24.string().min(1).describe("Canvas markdown body content.")
+    inputSchema: z25.object({
+      title: z25.string().min(1).max(160).describe("Canvas title."),
+      markdown: z25.string().min(1).describe("Canvas markdown body content.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ title, markdown }) => {
@@ -8684,35 +8927,35 @@ function createSlackCanvasCreateTool(context, state) {
 }
 
 // src/chat/slack/tools/canvas/edit.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 function prepareCanvasEditArguments(input) {
   return prepareTextReplacementArguments(input);
 }
-var editReplacementSchema2 = z25.object({
-  oldText: z25.string().min(1).describe(
+var editReplacementSchema2 = z26.object({
+  oldText: z26.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: z25.string().describe("Replacement Canvas markdown for this edit.")
+  newText: z26.string().describe("Replacement Canvas markdown for this edit.")
 });
 var slackCanvasEditOutputSchema = juniorToolResultSchema.extend({
-  canvas_id: z25.string().optional(),
-  title: z25.string().optional(),
-  permalink: z25.string().optional(),
-  diff: z25.string().optional(),
-  first_changed_line: z25.number().int().positive().optional(),
-  replacements: z25.number().int().nonnegative().optional(),
-  normalized_heading_count: z25.number().int().nonnegative().optional(),
-  summary: z25.string().optional(),
-  deduplicated: z25.boolean().optional()
+  canvas_id: z26.string().optional(),
+  title: z26.string().optional(),
+  permalink: z26.string().optional(),
+  diff: z26.string().optional(),
+  first_changed_line: z26.number().int().positive().optional(),
+  replacements: z26.number().int().nonnegative().optional(),
+  normalized_heading_count: z26.number().int().nonnegative().optional(),
+  summary: z26.string().optional(),
+  deduplicated: z26.boolean().optional()
 }).strict();
 function createSlackCanvasEditTool(state) {
   return zodTool({
     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.",
     prepareArguments: prepareCanvasEditArguments,
     executionMode: "sequential",
-    inputSchema: z25.object({
-      canvas: z25.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
-      edits: z25.array(editReplacementSchema2).min(1).describe(
+    inputSchema: z26.object({
+      canvas: z26.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
+      edits: z26.array(editReplacementSchema2).min(1).describe(
         "Exact replacements matched against the current Canvas body, not incrementally."
       )
     }),
@@ -8790,29 +9033,29 @@ function createSlackCanvasEditTool(state) {
 }
 
 // src/chat/slack/tools/canvas/read.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var slackCanvasReadOutputSchema = juniorToolResultSchema.extend({
-  canvas_id: z26.string().optional(),
-  title: z26.string().optional(),
-  permalink: z26.string().optional(),
-  mimetype: z26.string().optional(),
-  filetype: z26.string().optional(),
-  original_byte_length: z26.number().int().nonnegative().optional(),
-  content: z26.string().optional(),
-  start_line: z26.number().int().positive().optional(),
-  end_line: z26.number().int().nonnegative().optional(),
-  total_lines: z26.number().int().nonnegative().optional()
+  canvas_id: z27.string().optional(),
+  title: z27.string().optional(),
+  permalink: z27.string().optional(),
+  mimetype: z27.string().optional(),
+  filetype: z27.string().optional(),
+  original_byte_length: z27.number().int().nonnegative().optional(),
+  content: z27.string().optional(),
+  start_line: z27.number().int().positive().optional(),
+  end_line: z27.number().int().nonnegative().optional(),
+  total_lines: z27.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.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z26.object({
-      canvas: z26.string().min(1).describe(
+    inputSchema: z27.object({
+      canvas: z27.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: z26.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
-      limit: z26.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
+      offset: z27.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
+      limit: z27.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
     }),
     outputSchema: slackCanvasReadOutputSchema,
     execute: async ({ canvas, offset, limit }) => {
@@ -8869,14 +9112,14 @@ function createSlackCanvasReadTool() {
 }
 
 // src/chat/slack/tools/canvas/write.ts
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 function createSlackCanvasWriteTool(state) {
   return zodTool({
     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.",
     executionMode: "sequential",
-    inputSchema: z27.object({
-      canvas: z27.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
-      content: z27.string().describe("UTF-8 markdown content to write.")
+    inputSchema: z28.object({
+      canvas: z28.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
+      content: z28.string().describe("UTF-8 markdown content to write.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ canvas, content }) => {
@@ -9112,12 +9355,12 @@ async function updateListItem(input) {
 }
 
 // src/chat/slack/id-param.ts
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 function slackChannelIdParam(description) {
-  return z28.string().min(1).describe(description);
+  return z29.string().min(1).describe(description);
 }
 function slackUserIdParam(description) {
-  return z28.string().min(1).describe(description);
+  return z29.string().min(1).describe(description);
 }
 function parseRequiredSlackChannelIdParam(field, value) {
   const channelId = parseSlackChannelId(value);
@@ -9141,16 +9384,16 @@ function parseRequiredSlackUserIdParam(field, value) {
 }
 
 // src/chat/slack/tools/list/add-items.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 function createSlackListAddItemsTool(state) {
   return zodTool({
     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: z29.object({
-      items: z29.array(z29.string().min(1)).min(1).max(25).describe("List item titles to create."),
+    inputSchema: z30.object({
+      items: z30.array(z30.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: z29.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Optional due date in YYYY-MM-DD format.").optional()
+      due_date: z30.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Optional due date in YYYY-MM-DD format.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ items, assignee_user_id, due_date }) => {
@@ -9204,12 +9447,12 @@ function createSlackListAddItemsTool(state) {
 }
 
 // src/chat/slack/tools/list/create.ts
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 function createSlackListCreateTool(state) {
   return zodTool({
     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: z30.object({
-      name: z30.string().min(1).max(160).describe("Name for the new Slack list.")
+    inputSchema: z31.object({
+      name: z31.string().min(1).max(160).describe("Name for the new Slack list.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ name }) => {
@@ -9241,13 +9484,13 @@ function createSlackListCreateTool(state) {
 }
 
 // src/chat/slack/tools/list/get-items.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 function createSlackListGetItemsTool(state) {
   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.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z31.object({
-      limit: z31.coerce.number().int().min(1).max(200).describe("Maximum number of list items to return.").optional()
+    inputSchema: z32.object({
+      limit: z32.coerce.number().int().min(1).max(200).describe("Maximum number of list items to return.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ limit }) => {
@@ -9272,21 +9515,21 @@ function createSlackListGetItemsTool(state) {
 }
 
 // src/chat/slack/tools/list/update-item.ts
-import { z as z32 } from "zod";
-var booleanInput3 = (description) => z32.preprocess(
+import { z as z33 } from "zod";
+var booleanInput3 = (description) => z33.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z32.boolean()
+  z33.boolean()
 ).describe(description);
-var updateListItemInputSchema = z32.union([
-  z32.object({
-    item_id: z32.string().min(1).describe("ID of the Slack list item to update."),
+var updateListItemInputSchema = z33.union([
+  z33.object({
+    item_id: z33.string().min(1).describe("ID of the Slack list item to update."),
     completed: booleanInput3("Optional completion status update."),
-    title: z32.string().min(1).describe("Optional new item title.").optional()
+    title: z33.string().min(1).describe("Optional new item title.").optional()
   }),
-  z32.object({
-    item_id: z32.string().min(1).describe("ID of the Slack list item to update."),
+  z33.object({
+    item_id: z33.string().min(1).describe("ID of the Slack list item to update."),
     completed: booleanInput3("Optional completion status update.").optional(),
-    title: z32.string().min(1).describe("Optional new item title.")
+    title: z33.string().min(1).describe("Optional new item title.")
   })
 ]);
 function createSlackListUpdateItemTool(state) {
@@ -9362,7 +9605,7 @@ async function checkSlackChannelReadAccess(args) {
 }
 
 // src/chat/slack/tools/thread-read.ts
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 
 // src/chat/slack/tools/slack-message-url.ts
 var SLACK_HOST_PATTERN = /^[a-z0-9-]+\.slack(?:-gov)?\.com$/;
@@ -9535,8 +9778,8 @@ function createSlackThreadReadTool(context, deps = {}) {
   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.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z33.object({
-      url: z33.string().min(1).describe(
+    inputSchema: z34.object({
+      url: z34.string().min(1).describe(
         "Slack message archive URL, e.g. https://workspace.slack.com/archives/C123/p1700000000123456"
       ).optional(),
       channel_id: slackChannelIdParam(
@@ -9545,8 +9788,8 @@ function createSlackThreadReadTool(context, deps = {}) {
       ts: slackTimestampParam(
         "Slack message timestamp (e.g. 1700000000.123456). May be the thread root or any message in the thread."
       ).optional(),
-      limit: z33.coerce.number().int().min(1).max(1e3).describe("Maximum number of thread messages to fetch.").optional(),
-      max_pages: z33.coerce.number().int().min(1).max(10).describe("Maximum number of Slack API pages to traverse.").optional()
+      limit: z34.coerce.number().int().min(1).max(1e3).describe("Maximum number of thread messages to fetch.").optional(),
+      max_pages: z34.coerce.number().int().min(1).max(10).describe("Maximum number of Slack API pages to traverse.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ url, channel_id, ts, limit, max_pages }) => {
@@ -9802,29 +10045,29 @@ async function searchSlackUsers(options) {
 }
 
 // src/chat/slack/tools/user-lookup.ts
-import { z as z34 } from "zod";
-var booleanInput4 = (description) => z34.preprocess(
+import { z as z35 } from "zod";
+var booleanInput4 = (description) => z35.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z34.boolean()
+  z35.boolean()
 ).describe(description);
 function createSlackUserLookupTool() {
   return zodTool({
     description: "Look up Slack user profiles by user ID, email, or name search. Use when you need to identify a user, resolve cross-platform identity, or look up profile details like title or status. Returns profile fields including custom fields. For user ID lookup, pass a Slack user ID (e.g. U039RR91S). For search, pass a name query.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z34.object({
+    inputSchema: z35.object({
       user_id: slackUserIdParam(
         "Slack user ID to look up (e.g. U039RR91S). Mutually exclusive with email and query."
       ).optional(),
-      email: z34.string().min(3).describe(
+      email: z35.string().min(3).describe(
         "Email address to look up. Mutually exclusive with user_id and query."
       ).optional(),
-      query: z34.string().min(2).describe(
+      query: z35.string().min(2).describe(
         "Name to search for (matches against username, display name, real name). Mutually exclusive with user_id and email."
       ).optional(),
-      limit: z34.coerce.number().int().min(1).max(20).describe(
+      limit: z35.coerce.number().int().min(1).max(20).describe(
         "Maximum number of results to return for name search. Defaults to 10."
       ).optional(),
-      max_pages: z34.coerce.number().int().min(1).max(5).describe(
+      max_pages: z35.coerce.number().int().min(1).max(5).describe(
         "Maximum number of Slack API pages to scan for name search. Defaults to 3."
       ).optional(),
       include_bots: booleanInput4(
@@ -9928,18 +10171,18 @@ function createSlackUserLookupTool() {
 }
 
 // src/chat/tools/system-time.ts
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 var systemTimeOutputSchema = juniorToolResultSchema.extend({
-  unix_ms: z35.number(),
-  iso_utc: z35.string(),
-  iso_local: z35.string(),
-  timezone_offset_minutes: z35.number()
+  unix_ms: z36.number(),
+  iso_utc: z36.string(),
+  iso_local: z36.string(),
+  timezone_offset_minutes: z36.number()
 });
 function createSystemTimeTool() {
   return zodTool({
     description: "Return current system time in UTC and local ISO formats. Use when the user asks for current time/date context. Do not use as a substitute for historical or timezone-conversion research.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z35.object({}),
+    inputSchema: z36.object({}),
     outputSchema: systemTimeOutputSchema,
     privateTraceResult: (result) => ({
       ok: result.ok,
@@ -9968,32 +10211,32 @@ function createSystemTimeTool() {
 }
 
 // src/chat/tools/query-conversation-events.ts
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 var DEFAULT_LIMIT3 = 25;
 var MAX_LIMIT = 100;
 var CONVERSATION_EVENTS_TOOL_SOURCE = {
   id: "conversation-events",
   description: "Inspect Junior's durable conversation event log for debugging runtime behavior."
 };
-var knownEventTypeSchema = z36.enum(KNOWN_CONVERSATION_EVENT_TYPES);
-var projectedEventSchema = z36.object({
-  seq: z36.number().int().nonnegative().describe("Stable event position; use it for pagination bounds."),
-  history_version: z36.number().int().nonnegative().describe(
+var knownEventTypeSchema = z37.enum(KNOWN_CONVERSATION_EVENT_TYPES);
+var projectedEventSchema = z37.object({
+  seq: z37.number().int().nonnegative().describe("Stable event position; use it for pagination bounds."),
+  history_version: z37.number().int().nonnegative().describe(
     "Model-history generation. It increments when handoff or compaction replaces active model context."
   ),
-  created_at: z36.iso.datetime().describe("When the event was recorded."),
-  idempotency_key: z36.string().min(1).optional().describe("Retry-stable event identity, when one was assigned."),
-  data: z36.record(z36.string(), z36.unknown()).describe(
+  created_at: z37.iso.datetime().describe("When the event was recorded."),
+  idempotency_key: z37.string().min(1).optional().describe("Retry-stable event identity, when one was assigned."),
+  data: z37.record(z37.string(), z37.unknown()).describe(
     "Event payload. The type field identifies the event; replacement-history events report replacement_history_count instead of replaying the full model context."
   )
 }).strict();
 var queryConversationEventsOutputSchema = juniorToolResultSchema.extend({
-  conversation_id: z36.string().min(1),
-  events: z36.array(projectedEventSchema),
-  has_older: z36.boolean().describe(
+  conversation_id: z37.string().min(1),
+  events: z37.array(projectedEventSchema),
+  has_older: z37.boolean().describe(
     "Whether matching events exist before this page; request them with before_seq set to the first returned seq."
   ),
-  has_newer: z36.boolean().describe(
+  has_newer: z37.boolean().describe(
     "Whether matching events exist after this page; request them with after_seq set to the last returned seq."
   )
 });
@@ -10003,20 +10246,20 @@ function createQueryConversationEventsTool(context) {
     exposure: "deferred",
     source: CONVERSATION_EVENTS_TOOL_SOURCE,
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z36.object({
-      conversation_id: z36.string().trim().min(1).describe(
+    inputSchema: z37.object({
+      conversation_id: z37.string().trim().min(1).describe(
         "Conversation ID to inspect, such as slack:{channelId}:{threadTs} or a child conversation id."
       ),
-      after_seq: z36.number().int().nonnegative().nullable().describe(
+      after_seq: z37.number().int().nonnegative().nullable().describe(
         "Exclusive lower bound on event seq. When set, returns the next newer page in ascending order."
       ).optional(),
-      before_seq: z36.number().int().nonnegative().nullable().describe(
+      before_seq: z37.number().int().nonnegative().nullable().describe(
         "Exclusive upper bound on event seq. Combine with defaults or after_seq to page older or bounded ranges."
       ).optional(),
-      limit: z36.number().int().min(1).max(MAX_LIMIT).nullable().describe(
+      limit: z37.number().int().min(1).max(MAX_LIMIT).nullable().describe(
         `Maximum events to return. Defaults to ${DEFAULT_LIMIT3}; max ${MAX_LIMIT}.`
       ).optional(),
-      types: z36.array(knownEventTypeSchema).min(1).nullable().describe(
+      types: z37.array(knownEventTypeSchema).min(1).nullable().describe(
         "Optional event-type filter. Omit to return every durable event type."
       ).optional()
     }).strict(),
@@ -10206,10 +10449,10 @@ function stripReplacementHistoryField(value) {
 }
 
 // src/chat/tools/handoff/tool.ts
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 var HANDOFF_TOOL_NAME = "handoff";
 function createHandoffTool(handoff) {
-  const profileSchema = z37.enum(handoff.profiles);
+  const profileSchema = z38.enum(handoff.profiles);
   const handoffResultSchema = juniorToolResultSchema.extend({
     model_profile: profileSchema
   });
@@ -10217,7 +10460,7 @@ function createHandoffTool(handoff) {
   return zodTool({
     description: `Switch to another execution profile and continue the same task. Profiles: ${profileNames}. Call this as the only tool.`,
     executionMode: "sequential",
-    inputSchema: z37.object({
+    inputSchema: z38.object({
       profile: profileSchema.describe("Target execution profile")
     }).strict(),
     outputSchema: handoffResultSchema,
@@ -10240,7 +10483,7 @@ function createHandoffTool(handoff) {
 }
 
 // src/chat/tools/web/fetch-tool.ts
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 
 // src/chat/tools/web/constants.ts
 var USER_AGENT = "junior-bot/0.1";
@@ -10368,7 +10611,7 @@ async function fetchWithPinnedLookup(url, resolved, signal) {
   }
   const client = url.protocol === "https:" ? https : http;
   const lookup = createPinnedLookup(resolved);
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const request = client.request(
       {
         protocol: url.protocol,
@@ -10398,7 +10641,7 @@ async function fetchWithPinnedLookup(url, resolved, signal) {
             }
             const rawStatus = response.statusCode ?? 500;
             const status = rawStatus >= 200 && rawStatus <= 599 ? rawStatus : 502;
-            resolve(
+            resolve2(
               new Response(Buffer.concat(chunks), {
                 status,
                 headers
@@ -10690,9 +10933,9 @@ function createWebFetchTool(hooks, options = {}) {
       destructiveHint: false,
       openWorldHint: true
     },
-    inputSchema: z38.object({
-      url: z38.string().min(1).describe("HTTP(S) URL to fetch."),
-      max_chars: z38.coerce.number().int().min(500).max(MAX_FETCH_CHARS).describe("Optional maximum number of extracted characters to return.").optional()
+    inputSchema: z39.object({
+      url: z39.string().min(1).describe("HTTP(S) URL to fetch."),
+      max_chars: z39.coerce.number().int().min(500).max(MAX_FETCH_CHARS).describe("Optional maximum number of extracted characters to return.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ url, max_chars }) => {
@@ -10753,7 +10996,7 @@ function createWebFetchTool(hooks, options = {}) {
 }
 
 // src/chat/tools/web/search.ts
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 import { generateText } from "ai";
 import { createGatewayProvider } from "@ai-sdk/gateway";
 var SEARCH_TIMEOUT_MS = 6e4;
@@ -10802,9 +11045,9 @@ function createWebSearchTool(modelId, override) {
       destructiveHint: false,
       openWorldHint: true
     },
-    inputSchema: z39.object({
-      query: z39.string().min(1).max(500).describe("Search query."),
-      max_results: z39.coerce.number().int().min(1).max(MAX_RESULTS2).describe("Max results to return.").optional()
+    inputSchema: z40.object({
+      query: z40.string().min(1).max(500).describe("Search query."),
+      max_results: z40.coerce.number().int().min(1).max(MAX_RESULTS2).describe("Max results to return.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ query, max_results }) => {
@@ -10873,14 +11116,14 @@ function createWebSearchTool(modelId, override) {
 }
 
 // src/chat/tools/sandbox/write-file.ts
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 function createWriteFileTool() {
   return zodTool({
     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: z40.object({
-      path: z40.string().min(1).describe("Path to write in the sandbox workspace."),
-      content: z40.string().describe("UTF-8 file content to write.")
+    inputSchema: z41.object({
+      path: z41.string().min(1).describe("Path to write in the sandbox workspace."),
+      content: z41.string().describe("UTF-8 file content to write.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async () => {
@@ -10920,7 +11163,7 @@ function createToolState(hooks, context) {
     }
   };
 }
-function createTools(availableSkills, hooks = {}, context) {
+function createTools(availableSkills, hooks = {}, context, options = {}) {
   const state = createToolState(hooks, context);
   const slackContext = getSlackToolContext(context);
   const slackSourceCapabilities = slackContext ? resolveChannelCapabilities(slackContext.sourceChannelId) : void 0;
@@ -10928,9 +11171,11 @@ function createTools(availableSkills, hooks = {}, context) {
     slackContext && slackSourceCapabilities?.canSendFiles
   );
   const tools = {
-    loadSkill: createLoadSkillTool(availableSkills, {
-      onSkillLoaded: hooks.onSkillLoaded
-    }),
+    ...options.includeLoadSkill === false ? {} : {
+      loadSkill: createLoadSkillTool(availableSkills, {
+        onSkillLoaded: hooks.onSkillLoaded
+      })
+    },
     reportProgress: createReportProgressTool(),
     systemTime: createSystemTimeTool(),
     bash: createBashTool(),
@@ -10952,6 +11197,13 @@ function createTools(availableSkills, hooks = {}, context) {
   if (context.conversationId) {
     tools.queryConversationEvents = createQueryConversationEventsTool(context);
   }
+  if (context.supportsImageInput) {
+    tools.viewImage = createViewImageTool(
+      context.workspace,
+      context.supportsImageInput,
+      hooks.toolOverrides?.viewImage
+    );
+  }
   if (hooks.writeGeneratedArtifacts) {
     tools.imageGenerate = createImageGenerateTool(
       {
@@ -11546,6 +11798,8 @@ function isPluginToolInputError(error) {
 }
 function getToolErrorType(error) {
   if (error instanceof McpToolError) return "tool_error";
+  if (error instanceof McpProviderError) return "mcp_provider_error";
+  if (error instanceof OAuthProviderError) return "oauth_provider_error";
   if (error instanceof ToolInputError || isPluginToolInputError(error)) {
     return "tool_input_error";
   }
@@ -11568,6 +11822,8 @@ function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, trac
   const errorMessage = getMcpAwareTelemetryMessage(error, conversationPrivacy);
   const errorAttributes = {
     "error.type": errorType,
+    ...getMcpProviderErrorAttributes(error),
+    ...getOAuthProviderErrorAttributes(error),
     ...error instanceof PluginCredentialFailureError ? { "app.credential.provider": error.provider } : {}
   };
   if (setExecutionSpanAttributes) {
@@ -11600,7 +11856,7 @@ function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, trac
         "gen_ai.operation.name": "execute_tool",
         "gen_ai.tool.name": toolName,
         ...toolCallId ? { "gen_ai.tool.call.id": toolCallId } : {},
-        "error.type": errorType,
+        ...errorAttributes,
         "exception.message": errorMessage
       },
       "Agent tool call failed"
@@ -11616,6 +11872,7 @@ function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, trac
         "gen_ai.operation.name": "execute_tool",
         "gen_ai.tool.name": toolName,
         ...toolCallId ? { "gen_ai.tool.call.id": toolCallId } : {},
+        ...errorAttributes,
         ...getToolErrorAttributes(error)
       },
       "Agent tool call failed"
@@ -11625,17 +11882,17 @@ function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, trac
 }
 
 // src/chat/tools/execute-tool.ts
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 var EXECUTE_TOOL_NAME = "executeTool";
 function createExecuteToolTool() {
   return zodTool({
     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: z41.object({
-      tool_name: z41.string().min(1).describe(
+    inputSchema: z42.object({
+      tool_name: z42.string().min(1).describe(
         "Exact catalog tool_name returned by searchTools or a tool-result execution hint."
       ),
-      arguments: z41.record(z41.string(), z41.unknown()).describe(
+      arguments: z42.record(z42.string(), z42.unknown()).describe(
         'Arguments matching the selected catalog tool schema, for example { "query": "..." }.'
       ).optional()
     }).strict(),
@@ -11675,42 +11932,42 @@ function planToolExposure(tools) {
 }
 
 // src/chat/tools/search-tools.ts
-import { z as z42 } from "zod";
+import { z as z43 } from "zod";
 var SEARCH_TOOLS_NAME = "searchTools";
 var DEFAULT_MAX_RESULTS2 = 5;
 var MAX_RESULTS3 = 20;
 var MODEL_VISIBLE_DESCRIPTION_CAP = 180;
-var searchToolsSourceSchema = z42.object({
-  id: z42.string(),
-  description: z42.string()
+var searchToolsSourceSchema = z43.object({
+  id: z43.string(),
+  description: z43.string()
 }).strict();
-var toolCallExampleSchema = z42.object({
-  tool_name: z42.string(),
-  arguments: z42.record(z42.string(), z42.string())
+var toolCallExampleSchema = z43.object({
+  tool_name: z43.string(),
+  arguments: z43.record(z43.string(), z43.string())
 }).strict();
-var searchToolsToolSchema = z42.object({
-  tool_name: z42.string(),
-  description: z42.string(),
-  exposure: z42.enum(["direct", "deferred", "modelOnly", "hidden"]),
-  source: z42.string().optional(),
-  signature: z42.string(),
+var searchToolsToolSchema = z43.object({
+  tool_name: z43.string(),
+  description: z43.string(),
+  exposure: z43.enum(["direct", "deferred", "modelOnly", "hidden"]),
+  source: z43.string().optional(),
+  signature: z43.string(),
   call: toolCallExampleSchema,
-  input_schema: z42.unknown(),
-  input_schema_summary: z42.string(),
-  call_notes: z42.array(z42.string()),
-  annotations: z42.record(z42.string(), z42.unknown())
+  input_schema: z43.unknown(),
+  input_schema_summary: z43.string(),
+  call_notes: z43.array(z43.string()),
+  annotations: z43.record(z43.string(), z43.unknown())
 }).strict();
 var searchToolsOutputSchema = juniorToolResultSchema.extend({
-  query: z42.string().nullable(),
-  source: z42.string().nullable(),
-  sources: z42.array(searchToolsSourceSchema),
-  total_catalog_tools: z42.number().int().nonnegative(),
-  total_eligible_tools: z42.number().int().nonnegative(),
-  total_matches: z42.number().int().nonnegative(),
-  returned_tools: z42.number().int().nonnegative(),
-  execution_tool: z42.literal("executeTool"),
+  query: z43.string().nullable(),
+  source: z43.string().nullable(),
+  sources: z43.array(searchToolsSourceSchema),
+  total_catalog_tools: z43.number().int().nonnegative(),
+  total_eligible_tools: z43.number().int().nonnegative(),
+  total_matches: z43.number().int().nonnegative(),
+  returned_tools: z43.number().int().nonnegative(),
+  execution_tool: z43.literal("executeTool"),
   execution_example: toolCallExampleSchema,
-  tools: z42.array(searchToolsToolSchema)
+  tools: z43.array(searchToolsToolSchema)
 }).strict();
 function normalize2(value) {
   return value.toLowerCase().replace(/[^a-z0-9_]+/g, " ").trim();
@@ -11902,14 +12159,14 @@ function createSearchToolsTool(catalogTools) {
   return zodTool({
     description: renderSearchToolsDescription(knownSources),
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z42.object({
-      query: z42.string().nullable().describe(
+    inputSchema: z43.object({
+      query: z43.string().nullable().describe(
         "Optional search terms describing the tool, owner, action, or arguments needed. Empty string lists catalog tools."
       ).optional(),
-      source: z42.string().nullable().describe(
+      source: z43.string().nullable().describe(
         "Optional source id to search within, such as a plugin source returned in sources."
       ).optional(),
-      max_results: z42.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
+      max_results: z43.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
     }).strict(),
     outputSchema: searchToolsOutputSchema,
     privateTraceResult: (result) => ({
@@ -12027,7 +12284,8 @@ function createPiAgentTools(tools, sandbox, spanContext, onStatus, sandboxTools,
     const result = isSandbox ? await sandboxTools.execute({
       toolName,
       input: sandboxInput,
-      ...signal ? { signal } : {}
+      ...signal ? { signal } : {},
+      ...toolName === "grep" || toolName === "findFiles" ? { setToolCallSpanAttributes: setSpanAttributes2 } : {}
     }) : await toolDef.execute(toolInput, {
       experimental_context: sandbox,
       ...signal ? { signal } : {},
@@ -13174,6 +13432,27 @@ function createPluginEgress(deps) {
 }
 
 // src/chat/agent/tools.ts
+async function tryRecordSkillLoadStat(skill, spanContext) {
+  if (!process.env.DATABASE_URL) return;
+  try {
+    await incrementStat({
+      namespace: skill.pluginProvider ?? "junior",
+      metric: "skill_load",
+      name: skill.name
+    });
+  } catch (error) {
+    logWarn(
+      "skill_load_stat_failed",
+      spanContext,
+      {
+        "app.skill.name": skill.name,
+        "app.plugin.name": skill.pluginProvider,
+        "exception.message": error instanceof Error ? error.message : String(error)
+      },
+      "Failed to record skill load stat"
+    );
+  }
+}
 async function wireAgentTools(args) {
   const runSource = args.routing.source;
   const credentialUserId = args.routing.credentialContext ? credentialUserSubjectId(args.routing.credentialContext) : void 0;
@@ -13248,6 +13527,9 @@ async function wireAgentTools(args) {
   const loadableSkills = args.availableSkills.filter(
     (skill) => skill.disableModelInvocation !== true || skill.name === args.invokedSkill?.name
   );
+  const explicitSkillLoaded = Boolean(
+    args.invokedSkill && args.activeSkills.some((skill) => skill.name === args.invokedSkill?.name)
+  );
   const commonToolRuntimeContext = {
     conversationId: args.conversationId,
     userText: args.userInput,
@@ -13272,6 +13554,7 @@ async function wireAgentTools(args) {
     }),
     mcpToolManager,
     workspace: agentSandbox.workspace,
+    supportsImageInput: args.supportsImageInput,
     surface: args.surface,
     ...args.requestHandoff ? { handoff: args.requestHandoff } : {}
   };
@@ -13327,6 +13610,7 @@ async function wireAgentTools(args) {
         if (await mcpToolManager.activateForSkill(effective)) {
           await args.recordConnectedMcpProvider(effective.pluginProvider);
         }
+        await tryRecordSkillLoadStat(effective, args.spanContext);
         if (mcpAuth.getPendingPause()) {
           return void 0;
         }
@@ -13345,7 +13629,8 @@ async function wireAgentTools(args) {
         };
       }
     },
-    toolRuntimeContext
+    toolRuntimeContext,
+    { includeLoadSkill: !explicitSkillLoaded }
   );
   const plannedToolExposure = planToolExposure(
     tools
@@ -13430,7 +13715,11 @@ async function wireAgentTools(args) {
           "mcp_tool_manager_close_failed",
           {},
           {
-            "exception.message": closeError instanceof Error ? closeError.message : String(closeError)
+            ...getMcpProviderErrorAttributes(closeError),
+            "exception.message": getMcpAwareTelemetryMessage(
+              closeError,
+              args.conversationPrivacy
+            )
           },
           "Failed to close MCP tool manager"
         );
@@ -13454,6 +13743,7 @@ function createResumeState(args) {
   let latestSafeBoundaryMessages = [];
   let timedOut = false;
   let resumeMessages = [];
+  let turnContexts = [];
   let turnStartMessageIndex;
   const currentSliceId = args.sessionRecordState.currentSliceId;
   const currentDurationMs = () => Date.now() - args.startedAtMs;
@@ -13487,6 +13777,9 @@ function createResumeState(args) {
     setBeforeMessageCount(count) {
       beforeMessageCount = count;
     },
+    setTurnContexts(contexts) {
+      turnContexts = contexts;
+    },
     /** Adopt an already committed epoch replacement as every resume baseline. */
     adoptCommittedBoundary(messages) {
       latestSafeBoundaryMessages = [...messages];
@@ -13514,6 +13807,7 @@ function createResumeState(args) {
         sliceId: currentSliceId,
         messages,
         ...trailingMessageProvenance ? { trailingMessageProvenance } : {},
+        ...turnContexts.length > 0 ? { turnContexts } : {},
         ...turnStartMessageIndex !== void 0 ? { turnStartMessageIndex } : {}
       });
       if (!persisted) {
@@ -13780,6 +14074,27 @@ function renderSummaryInput(piMessages, conversationContext) {
 }
 async function summarizeContext(args, deps) {
   const source = renderSummaryInput(args.piMessages, args.conversationContext);
+  const instructions = args.purpose === "active_turn" ? [
+    "You are performing an ACTIVE-TURN CONTEXT CHECKPOINT COMPACTION for Junior.",
+    "Create concise internal continuation state for the same agent run, which must continue the unfinished task immediately after this checkpoint.",
+    "",
+    "Include:",
+    "- Work completed and concrete outcomes",
+    "- Exact work currently in progress",
+    "- The immediate next action",
+    "- Durable constraints, user preferences, IDs, URLs, artifacts, sandbox references, auth state, and unresolved blockers",
+    "",
+    "Do not write a user-facing reply, announce a plan, or imply that the task is complete unless the source history proves it is complete."
+  ] : [
+    "You are performing a CONTEXT CHECKPOINT COMPACTION for Junior.",
+    "Create a concise continuation summary for the agent that will continue this Slack thread.",
+    "",
+    "Include:",
+    "- Current outstanding asks",
+    "- Key decisions, completed work, and outcomes",
+    "- Durable constraints, user preferences, IDs, URLs, artifacts, canvas links, sandbox references, and auth state",
+    "- Clear next steps and unresolved blockers"
+  ];
   const result = await deps.completeText({
     modelId: botConfig.fastModelId,
     messageAttributeMode: "metadata",
@@ -13789,14 +14104,7 @@ async function summarizeContext(args, deps) {
       {
         role: "user",
         content: [
-          "You are performing a CONTEXT CHECKPOINT COMPACTION for Junior.",
-          "Create a concise continuation summary for the agent that will continue this Slack thread.",
-          "",
-          "Include:",
-          "- Current outstanding asks",
-          "- Key decisions, completed work, and outcomes",
-          "- Durable constraints, user preferences, IDs, URLs, artifacts, canvas links, sandbox references, and auth state",
-          "- Clear next steps and unresolved blockers",
+          ...instructions,
           "",
           "Do not invent details. Do not include raw secrets or credentials.",
           "",
@@ -14022,7 +14330,8 @@ async function compactActiveContextIfNeeded(args, deps) {
     summary = await summarizeContext(
       {
         ...args,
-        piMessages: args.piMessages
+        piMessages: args.piMessages,
+        purpose: "active_turn"
       },
       deps
     );
@@ -14052,22 +14361,15 @@ async function compactActiveContextIfNeeded(args, deps) {
     );
     return { compacted: false, reason: "summary_failed" };
   }
-  const summaryText = `${COMPACTION_SUMMARY_PREFIX}
-${summary}`;
-  const runtimeMessage = retainRuntimeTurnContext(args.piMessages).at(-1);
-  const summaryMessages = runtimeMessage ? [
-    {
-      ...runtimeMessage,
-      content: [
-        ...runtimeMessage.content,
-        { type: "text", text: summaryText }
-      ]
-    }
-  ] : [userMessage(summaryText)];
+  const summaryMessage = userMessage(
+    `${ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX}
+${summary}`
+  );
+  const runtimeMessages = retainRuntimeTurnContext(args.piMessages);
   const retainedInstruction = pendingMessages.length === 0 ? await loadLastInstruction(args.conversationId) : void 0;
   const instructionMessages = retainedInstruction ? [retainedInstruction.message] : pendingMessages.map((entry) => entry.message);
   const instructionProvenance = retainedInstruction ? [retainedInstruction.provenance] : pendingMessages.map((entry) => entry.provenance);
-  const messages = [...summaryMessages, ...instructionMessages];
+  const messages = [...runtimeMessages, ...instructionMessages, summaryMessage];
   const replacementInputTokens = estimateHistoryTokens(messages);
   if (replacementInputTokens >= inputLimitTokens) {
     throw new ContextInputLimitExceededError(
@@ -14100,10 +14402,11 @@ ${summary}`;
       },
       summary,
       replacementHistory: replacementMessages.map((message, index) => {
-        const provenance = index === 0 ? contextProvenance : instructionProvenance[index - 1];
+        const isSummary = index === replacementMessages.length - 1;
+        const provenance = isSummary ? contextProvenance : instructionProvenance[index];
         return {
           item: historyItemFromPiMessage(message, provenance),
-          ...index === 1 && retainedInstruction ? { sourceEventSeq: retainedInstruction.sourceEventSeq } : {}
+          ...index === 0 && retainedInstruction ? { sourceEventSeq: retainedInstruction.sourceEventSeq } : {}
         };
       })
     }
@@ -14130,12 +14433,12 @@ var AssistantMessageDeliveryError = class extends Error {
   originalError;
 };
 function waitForAbortSettlement(promise, timeoutMs) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     let done = false;
     const timeoutId = setTimeout(() => {
       if (!done) {
         done = true;
-        resolve(false);
+        resolve2(false);
       }
     }, timeoutMs);
     timeoutId.unref?.();
@@ -14144,14 +14447,14 @@ function waitForAbortSettlement(promise, timeoutMs) {
         if (!done) {
           done = true;
           clearTimeout(timeoutId);
-          resolve(true);
+          resolve2(true);
         }
       },
       () => {
         if (!done) {
           done = true;
           clearTimeout(timeoutId);
-          resolve(true);
+          resolve2(true);
         }
       }
     );
@@ -14374,6 +14677,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       skillSandbox,
       syncLoadedSkillNamesForResume
     });
+    const explicitSkill = invokedSkill ? activeSkills.find((skill) => skill.name === invokedSkill.name) ?? null : null;
     const { routerBlocks, userContentParts } = buildPromptInput(input);
     const preAgentPromptMessages = () => existingSessionRecord?.piMessages ?? [...input.piMessages ?? []];
     const storedTurnRoute = await loadTurnRoute({ conversationId, turnId });
@@ -14577,6 +14881,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       skillSandbox,
       spanContext,
       state,
+      supportsImageInput: () => resolveGatewayModel(activeModelId).input.includes("image"),
       surface,
       syncLoadedSkillNamesForResume,
       toolCalls,
@@ -14592,7 +14897,8 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       inputMessagesAttribute,
       promptContentParts,
       promptHistoryMessages,
-      shouldPromptAgent
+      shouldPromptAgent,
+      turnContexts
     } = await assemblePrompt({
       activeMcpCatalogs: wiring.activeMcpCatalogs,
       currentActor: actor,
@@ -14602,7 +14908,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       conversationPrivacy,
       existingSessionPiMessages: existingSessionRecord?.piMessages,
       existingTurnStartMessageIndex: existingSessionRecord?.turnStartMessageIndex,
-      invocation: skillInvocation,
+      explicitSkill,
       priorPiMessages,
       resumedFromSessionRecord,
       routing,
@@ -14611,6 +14917,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       toolRuntimeContext: wiring.toolRuntimeContext,
       userContentParts
     });
+    runResume.setTurnContexts(turnContexts);
     const applyPendingHandoff = () => {
       if (!pendingHandoff) {
         return void 0;