@sentry/junior 0.117.0 → 0.119.0

package/dist/{chunk-NHZEUHKH.js → chunk-TGIQN7QW.js}

@@ -25,13 +25,12 @@ import {
   patchMcpAuthSession,
   resolveBaseUrl,
   selectPluginGrant,
-  slackOutputPolicy,
   startOAuthFlow,
   surfaceFromRouting,
   toMcpProviderError,
   toolInvocationDestination,
   uploadFilesToConversation
-} from "./chunk-6G45D3YG.js";
+} from "./chunk-4UIUDOOV.js";
 import {
   CooperativeTurnYieldError,
   JUNIOR_THREAD_STATE_TTL_MS,
@@ -73,7 +72,7 @@ import {
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages,
   updateConversationStats
-} from "./chunk-27KWTFP6.js";
+} from "./chunk-BNJEPYTC.js";
 import {
   parseSandboxEgressAuthRequiredSignal,
   parseSandboxEgressPermissionDeniedSignal,
@@ -97,7 +96,10 @@ import {
   runNonInteractiveCommand,
   throwSandboxOperationError,
   wrapSandboxSetupError
-} from "./chunk-FAWBONPC.js";
+} from "./chunk-GKFDU3ZI.js";
+import {
+  incrementStat
+} from "./chunk-JXRAOOXQ.js";
 import {
   addAgentTurnUsage,
   hasAgentTurnUsage
@@ -106,30 +108,20 @@ import {
   privateTraceResultAttributes
 } from "./chunk-UIE3R5XU.js";
 import {
+  SlackActionError,
   createPluginHookRunner,
+  downloadPrivateSlackFile,
+  getFilePermalink,
   getPluginSystemPromptContributions,
   getPluginTools,
   getPluginUserPromptContributions,
-  getSlackToolContext,
-  resolveChannelCapabilities
-} from "./chunk-STUI6NIL.js";
-import {
-  SANDBOX_DATA_ROOT,
-  SANDBOX_SKILLS_ROOT,
-  SANDBOX_WORKSPACE_ROOT,
-  getStateAdapter,
-  sandboxSkillDir,
-  sandboxSkillFile
-} from "./chunk-KU6ALEJC.js";
-import {
-  SlackActionError,
-  downloadPrivateSlackFile,
-  getFilePermalink,
   getSlackClient,
+  getSlackToolContext,
   isConversationScopedChannel,
   normalizeSlackConversationId,
+  resolveChannelCapabilities,
   withSlackRetries
-} from "./chunk-YRWJ3KEU.js";
+} from "./chunk-BLQZACHV.js";
 import {
   KNOWN_CONVERSATION_EVENT_TYPES,
   contextProvenance,
@@ -138,10 +130,17 @@ import {
   getConversationStore,
   instructionActors,
   instructionProvenanceFor
-} from "./chunk-ZRQUQJUV.js";
+} from "./chunk-D3N4BPSL.js";
 import {
+  SANDBOX_DATA_ROOT,
+  SANDBOX_SKILLS_ROOT,
+  SANDBOX_WORKSPACE_ROOT,
+  getStateAdapter,
+  sandboxSkillDir,
+  sandboxSkillFile,
+  sandboxSkillPathResolution,
   sleep
-} from "./chunk-4ZNGQH7C.js";
+} from "./chunk-VJTWKJWQ.js";
 import {
   ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX,
   COMPACTION_SUMMARY_PREFIX,
@@ -172,7 +171,7 @@ import {
   renderCurrentInstruction,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-DS27ZBSP.js";
+} from "./chunk-VLTWQQKH.js";
 import {
   canExposeConversationPayload,
   parseSlackThreadId,
@@ -183,16 +182,16 @@ import {
   toGenAiMessagesTraceAttributes,
   toGenAiPayloadMetadata,
   toGenAiPayloadTraceAttributes
-} from "./chunk-FXOYURO4.js";
+} from "./chunk-HDFGNU5E.js";
 import {
   discoverSkills,
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-AKG4TZNH.js";
+} from "./chunk-QZ7XRJDB.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-CU7HTGNI.js";
+} from "./chunk-JSTGI7TX.js";
 import {
   CredentialUnavailableError,
   OAuthProviderError,
@@ -200,7 +199,7 @@ import {
   getOAuthProviderErrorAttributes,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv
-} from "./chunk-5O3JDQDG.js";
+} from "./chunk-R53UT2OI.js";
 import {
   credentialUserSubjectId
 } from "./chunk-W3U3YQYI.js";
@@ -224,7 +223,7 @@ import {
   summarizeMessageText,
   withLogContext,
   withSpan
-} from "./chunk-72Z3HNTQ.js";
+} from "./chunk-ZJ6IVZVO.js";
 import {
   parseSlackChannelId,
   parseSlackMessageTs,
@@ -1668,13 +1667,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 = [
@@ -1687,17 +1683,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) {
@@ -1810,7 +1795,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 = [
@@ -1874,13 +1860,11 @@ function buildOutputSection(platform) {
       "</output>"
     ].join("\n");
   }
-  const openTag = `<output format="slack-markdown" max_inline_chars="${slackOutputPolicy.maxInlineChars}" max_inline_lines="${slackOutputPolicy.maxInlineLines}">`;
   return [
-    openTag,
+    `<output format="slack-markdown">`,
+    "- Default to the shortest complete reply\u2014usually 1\u20135 sentences and under 800 characters. Include only the outcome, decisive evidence, and any blocker or required next action. If useful detail would exceed that, put it in a Slack canvas and reply with the link. An explicit user request for detail overrides this target.",
     "- Start with the answer or result, not internal process narration.",
     "- Use Slack-flavored Markdown: **bold** section labels, `code`, [text](url) links, bullet lists, and fenced code blocks. No hash-prefixed headings and no tables. When the answer primarily lists several URLs, show each URL bare instead of as a labeled link.",
-    "- Default to one compact thread reply containing the conclusion and only decisive evidence or action. Do not split an explainer across multiple Slack messages.",
-    "- Put plans, research, and other long or multi-section explainers in a Slack canvas; reply with one or two short sentences plus the link, without recapping the canvas.",
     "- End every turn with a final user-facing markdown response unless the Slack action rules allow a no-reply completion.",
     "</output>"
   ].join("\n");
@@ -1995,14 +1979,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;
@@ -2012,8 +1988,7 @@ function buildContextSection(params) {
 function buildCapabilitiesSection(params) {
   const blocks = [];
   const availableSkills = formatAvailableSkillsForPrompt(
-    params.availableSkills,
-    params.invocation
+    params.availableSkills
   );
   if (availableSkills) {
     blocks.push(availableSkills);
@@ -2094,7 +2069,6 @@ function buildTurnContextPrompt(params) {
     includeSessionContext ? buildCapabilitiesSection({
       availableSkills: params.availableSkills,
       activeMcpCatalogs: params.activeMcpCatalogs ?? [],
-      invocation: params.invocation,
       toolGuidance: params.toolGuidance ?? []
     }) : null,
     pluginPromptContributions,
@@ -2102,8 +2076,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));
@@ -2146,6 +2119,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;
@@ -2343,14 +2327,23 @@ 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 replayedPromptContent = shouldPromptAgent && !args.resumedFromSessionRecord ? checkpointedPromptContent({
     messages: args.existingSessionPiMessages,
     turnStartMessageIndex: args.existingTurnStartMessageIndex,
-    userContentParts: args.userContentParts
+    userContentParts: requestContentParts
   }) : void 0;
   const needsBootstrapContextForPrompt = shouldPromptAgent && !replayedPromptContent && !hasRuntimeTurnContext(promptHistoryMessages);
   const systemPromptContributions = await getPluginSystemPromptContributions(source);
@@ -2376,7 +2369,6 @@ 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
@@ -2384,7 +2376,7 @@ async function assemblePrompt(args) {
   const turnContextParts = turnContextPrompt ? [{ type: "text", text: turnContextPrompt }] : [];
   const promptContentParts = replayedPromptContent ?? [
     ...turnContextParts,
-    ...args.userContentParts
+    ...requestContentParts
   ];
   const inputMessages = [
     {
@@ -3076,6 +3068,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("/");
 }
@@ -3150,6 +3143,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) {
@@ -3219,13 +3222,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);
@@ -3822,6 +3833,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)) {
@@ -4409,7 +4421,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");
@@ -4420,6 +4432,7 @@ async function findFiles(params) {
     return await findFilesWithRipgrep({
       fs: params.fs,
       limit,
+      onTelemetry: params.onTelemetry,
       path: params.path,
       pattern: params.pattern,
       root,
@@ -4488,25 +4501,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) => {
@@ -4530,7 +4563,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",
@@ -4547,6 +4580,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({
@@ -4559,7 +4605,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 () => {
@@ -4612,6 +4658,7 @@ async function grepFiles(params) {
       ignoreCase: params.ignoreCase,
       limit,
       literal: params.literal,
+      onTelemetry: params.onTelemetry,
       path: params.path,
       pattern: params.pattern,
       root,
@@ -4759,7 +4806,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");
   }
@@ -4779,7 +4832,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";
@@ -4793,6 +4847,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;
@@ -4803,6 +4858,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;
     }
@@ -4884,7 +4940,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 ?? ".",
@@ -4903,6 +4959,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({
@@ -5242,11 +5311,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 }) => {
@@ -5267,10 +5337,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;
@@ -5515,10 +5606,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 } : {},
@@ -5547,10 +5643,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 } : {}
@@ -5583,7 +5684,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) {
@@ -6912,7 +7016,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
   };
 }
@@ -8540,20 +8644,156 @@ function extractCanvasId(input) {
   }
 }
 
-// src/chat/slack/tools/canvas/api.ts
+// src/chat/slack/tools/canvas/markdown.ts
+function getListType(marker) {
+  return /^\d/.test(marker) ? "numbered" : "bullet";
+}
+function getPlainListMarker(marker, type) {
+  return type === "numbered" ? `${marker.match(/^\d+/)?.[0] ?? "1"}:` : "\u2022";
+}
+function getIndentWidth(whitespace, startColumn = 0) {
+  let column = startColumn;
+  for (const character of whitespace) {
+    column += character === "	" ? 4 - column % 4 : 1;
+  }
+  return column - startColumn;
+}
+function getLineIndent(line) {
+  return getIndentWidth(line.match(/^[ \t]*/)?.[0] ?? "");
+}
+function getFence(line) {
+  const match = line.match(/^([ \t]*)(`{3,}|~{3,})(.*)$/);
+  const run = match?.[2];
+  if (!run) return void 0;
+  return {
+    fence: {
+      marker: run[0],
+      length: run.length
+    },
+    indent: getIndentWidth(match[1] ?? ""),
+    suffix: match[3] ?? ""
+  };
+}
+function isListBlockIndent(indent, listItems2) {
+  return listItems2.some(
+    (item) => indent >= item.contentIndent && indent <= item.contentIndent + 3
+  );
+}
+function canOpenFence(fenceLine, listItems2) {
+  return fenceLine.indent <= 3 || isListBlockIndent(fenceLine.indent, listItems2);
+}
+function unwrapNestedBlockquote(line, listItems2, maxQuoteDepth = Number.POSITIVE_INFINITY) {
+  const match = line.match(/^([ \t]+)((?:>[ \t]*)+)(.*)$/);
+  if (!match || !isListBlockIndent(getIndentWidth(match[1] ?? ""), listItems2)) {
+    return { line, quoteDepth: 0 };
+  }
+  let quotePrefix = match[2] ?? "";
+  const quoteDepth = Math.min(
+    quotePrefix.match(/>/g)?.length ?? 0,
+    maxQuoteDepth
+  );
+  for (let index = 0; index < quoteDepth; index += 1) {
+    quotePrefix = quotePrefix.replace(/^>[ \t]*/, "");
+  }
+  return {
+    line: `${match[1]}${quotePrefix}${match[3]}`,
+    quoteDepth
+  };
+}
 function normalizeCanvasMarkdown(markdown) {
   let normalizedHeadingCount = 0;
-  const normalized = markdown.split("\n").map(
-    (line) => line.replace(/^(#{4,})(?=\s)/, () => {
+  let normalizedMixedListCount = 0;
+  let unwrappedBlockquoteCount = 0;
+  let openFence;
+  const listItems2 = [];
+  const lines = markdown.split("\n").map((originalLine) => {
+    if (openFence) {
+      const unwrapped2 = openFence.quoteDepth > 0 ? unwrapNestedBlockquote(
+        originalLine,
+        listItems2,
+        openFence.quoteDepth
+      ) : { line: originalLine, quoteDepth: 0 };
+      if (unwrapped2.quoteDepth > 0) {
+        unwrappedBlockquoteCount += 1;
+      }
+      const fenceLine2 = getFence(unwrapped2.line);
+      if (fenceLine2?.fence.marker === openFence.marker && fenceLine2.fence.length >= openFence.length && !fenceLine2.suffix.trim()) {
+        openFence = void 0;
+      }
+      return unwrapped2.line;
+    }
+    const unwrapped = unwrapNestedBlockquote(originalLine, listItems2);
+    if (unwrapped.quoteDepth > 0) {
+      unwrappedBlockquoteCount += 1;
+    }
+    const line = unwrapped.line;
+    const fenceLine = getFence(line);
+    if (fenceLine && canOpenFence(fenceLine, listItems2)) {
+      const rootListContentIndent2 = listItems2[0]?.contentIndent;
+      if (rootListContentIndent2 !== void 0 && fenceLine.indent < rootListContentIndent2) {
+        listItems2.length = 0;
+      }
+      openFence = {
+        ...fenceLine.fence,
+        quoteDepth: unwrapped.quoteDepth
+      };
+      return line;
+    }
+    const listMatch = line.match(/^([ \t]*)([-+*]|\d+[.)])([ \t]+)(.*)$/);
+    if (listMatch) {
+      const [, whitespace = "", marker = "", gap = "", rawContent = ""] = listMatch;
+      const indent = getIndentWidth(whitespace);
+      const type = getListType(marker);
+      const markerEnd = indent + getIndentWidth(marker);
+      const contentIndent = markerEnd + getIndentWidth(gap, markerEnd);
+      const contentMatch = rawContent.match(/^(?:>[ \t]*)+(.*)$/);
+      const content = contentMatch?.[1] ?? rawContent;
+      if (contentMatch) {
+        unwrappedBlockquoteCount += 1;
+      }
+      while (listItems2.length > 0 && listItems2[listItems2.length - 1].indent >= indent) {
+        listItems2.pop();
+      }
+      const parent = listItems2[listItems2.length - 1];
+      if (parent && (parent.unwrapped || parent.type !== type)) {
+        listItems2.push({
+          contentIndent,
+          indent,
+          type: parent.type,
+          unwrapped: true
+        });
+        normalizedMixedListCount += 1;
+        return `${whitespace}${getPlainListMarker(marker, type)}${gap}${content}`;
+      }
+      listItems2.push({ contentIndent, indent, type, unwrapped: false });
+      return contentMatch ? `${whitespace}${marker}${gap}${content}` : line;
+    }
+    const rootListContentIndent = listItems2[0]?.contentIndent;
+    if (rootListContentIndent !== void 0 && line.trim() && getLineIndent(line) < rootListContentIndent) {
+      listItems2.length = 0;
+    }
+    const headingMatch = line.match(/^([ \t]*)#{4,}(?=[ \t])/);
+    const headingIndent = headingMatch ? getIndentWidth(headingMatch[1] ?? "") : void 0;
+    if (headingMatch && headingIndent !== void 0 && (headingIndent <= 3 || isListBlockIndent(headingIndent, listItems2))) {
       normalizedHeadingCount += 1;
-      return "###";
-    })
-  ).join("\n");
+      return line.replace(
+        /^([ \t]*)#{4,}(?=[ \t])/,
+        (_, indent) => `${indent}###`
+      );
+    }
+    return line;
+  });
+  const normalizedCount = normalizedHeadingCount + normalizedMixedListCount + unwrappedBlockquoteCount;
   return {
-    markdown: normalized,
-    normalizedHeadingCount
+    markdown: lines.join("\n"),
+    normalizedCount,
+    normalizedHeadingCount,
+    normalizedMixedListCount,
+    unwrappedBlockquoteCount
   };
 }
+
+// src/chat/slack/tools/canvas/api.ts
 async function createCanvas(input) {
   const client = getSlackClient();
   const normalizedChannelId = normalizeSlackConversationId(input.channelId);
@@ -8577,8 +8817,10 @@ async function createCanvas(input) {
         "app.slack.canvas.has_channel_id": Boolean(input.channelId),
         "app.slack.canvas.title_length": input.title.length,
         "app.slack.canvas.markdown_length": normalizedContent.markdown.length,
-        "app.slack.canvas.markdown_normalized": normalizedContent.normalizedHeadingCount > 0,
-        "app.slack.canvas.normalized_heading_count": normalizedContent.normalizedHeadingCount
+        "app.slack.canvas.markdown_normalized": normalizedContent.normalizedCount > 0,
+        "app.slack.canvas.normalized_heading_count": normalizedContent.normalizedHeadingCount,
+        "app.slack.canvas.normalized_mixed_list_count": normalizedContent.normalizedMixedListCount,
+        "app.slack.canvas.unwrapped_blockquote_count": normalizedContent.unwrappedBlockquoteCount
       }
     }
   );
@@ -8654,8 +8896,10 @@ async function writeCanvasMarkdown(input) {
         "app.slack.canvas.canvas_id_prefix": input.canvasId.slice(0, 1),
         "app.slack.canvas.operation": "replace",
         "app.slack.canvas.markdown_length": normalizedContent.markdown.length,
-        "app.slack.canvas.markdown_normalized": normalizedContent.normalizedHeadingCount > 0,
-        "app.slack.canvas.normalized_heading_count": normalizedContent.normalizedHeadingCount
+        "app.slack.canvas.markdown_normalized": normalizedContent.normalizedCount > 0,
+        "app.slack.canvas.normalized_heading_count": normalizedContent.normalizedHeadingCount,
+        "app.slack.canvas.normalized_mixed_list_count": normalizedContent.normalizedMixedListCount,
+        "app.slack.canvas.unwrapped_blockquote_count": normalizedContent.unwrappedBlockquoteCount
       }
     }
   );
@@ -11056,7 +11300,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;
@@ -11064,9 +11308,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(),
@@ -12175,7 +12421,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 } : {},
@@ -13322,6 +13569,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;
@@ -13396,6 +13664,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,
@@ -13476,6 +13747,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;
         }
@@ -13494,7 +13766,8 @@ async function wireAgentTools(args) {
         };
       }
     },
-    toolRuntimeContext
+    toolRuntimeContext,
+    { includeLoadSkill: !explicitSkillLoaded }
   );
   const plannedToolExposure = planToolExposure(
     tools
@@ -13948,7 +14221,8 @@ async function summarizeContext(args, deps) {
     "- 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."
+    "Do not write a user-facing reply or announce a plan.",
+    "Treat the task as complete only when the source history contains concrete evidence that every requested outcome occurred. Do not infer completion from intent, plans, progress, intermediate artifacts, or adjacent tool activity. If evidence is missing or ambiguous, preserve the task as unfinished and state the next required action."
   ] : [
     "You are performing a CONTEXT CHECKPOINT COMPACTION for Junior.",
     "Create a concise continuation summary for the agent that will continue this Slack thread.",
@@ -14541,6 +14815,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 });
@@ -14771,7 +15046,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       conversationPrivacy,
       existingSessionPiMessages: existingSessionRecord?.piMessages,
       existingTurnStartMessageIndex: existingSessionRecord?.turnStartMessageIndex,
-      invocation: skillInvocation,
+      explicitSkill,
       priorPiMessages,
       resumedFromSessionRecord,
       routing,