@sentry/junior 0.31.0 → 0.32.0

package/dist/app.d.ts

@@ -4,6 +4,8 @@ import { Hono } from 'hono';
 type WaitUntilFn = (task: Promise<unknown> | (() => Promise<unknown>)) => void;
 
 interface JuniorAppOptions {
+    /** Install-wide provider defaults (`provider.key` format). Channel overrides take precedence. */
+    configDefaults?: Record<string, unknown>;
     pluginPackages?: string[];
     waitUntil?: WaitUntilFn;
 }

package/dist/app.js

@@ -3,7 +3,7 @@ import {
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-3SH2A7VQ.js";
+} from "./chunk-EHXMTKBA.js";
 import {
   GEN_AI_PROVIDER_NAME,
   MISSING_GATEWAY_CREDENTIALS_ERROR,
@@ -30,7 +30,7 @@ import {
   runNonInteractiveCommand,
   sandboxSkillDir,
   sandboxSkillFile
-} from "./chunk-LEYD42MR.js";
+} from "./chunk-3M7ZD6FF.js";
 import {
   CredentialUnavailableError,
   buildOAuthTokenRequest,
@@ -46,6 +46,7 @@ import {
   getPluginOAuthConfig,
   getPluginProviders,
   hasRequiredOAuthScope,
+  isPluginConfigKey,
   isPluginProvider,
   isRecord,
   logError,
@@ -63,7 +64,7 @@ import {
   toOptionalString,
   withContext,
   withSpan
-} from "./chunk-RZJDO55D.js";
+} from "./chunk-XARRBRQV.js";
 import "./chunk-Z3YD6NHK.js";
 import {
   discoverInstalledPluginPackageContent,
@@ -78,6 +79,26 @@ import "./chunk-2KG3PWR4.js";
 // src/app.ts
 import { Hono } from "hono";
 
+// src/chat/configuration/defaults.ts
+var installDefaults = {};
+function setConfigDefaults(defaults) {
+  if (!defaults) {
+    installDefaults = {};
+    return;
+  }
+  for (const key of Object.keys(defaults)) {
+    if (!isPluginConfigKey(key)) {
+      throw new Error(
+        `configDefaults: "${key}" is not a registered plugin config key`
+      );
+    }
+  }
+  installDefaults = { ...defaults };
+}
+function getConfigDefaults() {
+  return installDefaults;
+}
+
 // src/handlers/diagnostics.ts
 import { readFileSync } from "fs";
 import path from "path";
@@ -2925,7 +2946,9 @@ function formatLoadedSkillsForPrompt(skills) {
     lines.push(
       `  <skill name="${escapeXml(skill.name)}" location="${escapeXml(`${skillDir}/SKILL.md`)}">`
     );
-    lines.push(`References are relative to ${escapeXml(skillDir)}.`);
+    lines.push(
+      `Skill directory: ${escapeXml(skillDir)}. Resolve relative paths there; for skill-owned bash commands, cd there first or use absolute paths.`
+    );
     lines.push("");
     lines.push(skill.body);
     lines.push("  </skill>");
@@ -3031,31 +3054,111 @@ function formatThreadParticipantsLines(participants) {
     return `- ${parts.join(", ")}`;
   });
 }
+function formatSlackCapabilityNames(capabilities) {
+  const names = [
+    capabilities?.canCreateCanvas ? "canvas_create" : "",
+    capabilities?.canPostToChannel ? "channel_post" : "",
+    capabilities?.canAddReactions ? "reaction_add" : ""
+  ].filter(Boolean);
+  return names.length > 0 ? names.join(", ") : "none";
+}
 var HEADER = "You are a Slack-based helper assistant. The behavior and output blocks below are authoritative; the personality block sets voice only.";
-var BEHAVIOR_RULES = [
-  "- Load the best-matching skill/tool when relevant, then use it before answering; do not preload multiple skills or claim tool use that did not happen.",
-  "- After `loadSkill`, resolve references under `skill_dir`; for active MCP catalogs, use `searchMcpTools` then `callMcpTool` with exact returned tool names.",
-  "- Default to acting in-turn: use relevant available skills/tools to satisfy the request, continue until done or blocked, and only ask the user when access or required input is missing. If a fact cannot be verified, say so.",
+var TOOL_POLICY_RULES = [
+  "- Tool schemas are the source of truth for parameters; tool names are case-sensitive, so call tools exactly by their exposed names and do not invent arguments.",
+  "- Use tools for actionable work and for facts that are mutable, external, repository-backed, provider-backed, or requested as verified/current. Stable general knowledge and already-provided context may be answered directly.",
+  "- Verification source order: conversation/thread context; user-provided attachments, links, and reference files; local/sandbox files when present; loaded skill references; repository/provider tools; public web. Use the nearest authoritative available source before weaker sources.",
+  "- For repository or implementation questions, inspect the target repository first: local checkout when present, otherwise the configured GitHub/source provider. Do not treat loaded skill files as repo source unless the user asks about the skill. Cite file paths, symbols, PRs/issues, commits, or URLs that support the answer.",
+  `- Sandbox-backed file and shell tools operate in an isolated workspace rooted at ${SANDBOX_WORKSPACE_ROOT}; readFile/writeFile paths are sandbox-workspace paths, bash runs inside that workspace, and attachFile accepts absolute or workspace-relative sandbox paths.`,
+  "- If a sandbox-backed tool reports that sandbox execution is unavailable, treat that as a blocker for local file/shell inspection; do not pretend host files were inspected.",
+  "- For user-provided URLs, use `webFetch`; for discovery, use `webSearch` then fetch/read promising sources; for current time/date context, use `systemTime`.",
+  "- If the first result is empty, stale, ambiguous, or incomplete, try a focused alternate query, path, command, or source before concluding the answer cannot be verified."
+];
+var TOOL_CALL_STYLE_RULES = [
+  "- For routine low-risk tool use, call the tool directly without narrating the obvious step first.",
+  "- Briefly narrate only when it helps the user understand multi-step work, sensitive actions, destructive actions, or a notable change in approach.",
+  "- When a first-class tool exists for an action, use it directly instead of asking the user to run an equivalent command, slash command, or manual lookup.",
+  "- Keep tool-call explanations separate from final answers; final answers should report results, evidence, or blockers."
+];
+var SKILL_POLICY_RULES = [
+  "- Before answering, scan `<available-skills>`. For matching operational or conceptual provider/repository workflow questions, load the most specific skill; do not answer from memory first. If none fits, do not load a skill.",
+  "- Never load multiple skills up front. After `loadSkill`, follow `<loaded-skills>` and resolve relative references under that skill's location.",
+  "- For explicit `/skill` triggers, treat that skill as selected unless the tool says it is unavailable.",
+  "- For active MCP catalogs, use `searchMcpTools` to inspect descriptors before `callMcpTool`; pass exact returned `tool_name` values and put provider fields inside `arguments`.",
+  "- Run authenticated provider commands directly after resolving target defaults; let the runtime handle auth pauses/resumes.",
+  "- Run `jr-rpc config get|set|unset|list` as standalone bash commands for conversation-scoped provider defaults; do not chain them with `cd`, `&&`, pipes, or provider commands."
+];
+var EXECUTION_CONTRACT_RULES = [
+  "- Actionable request: act in this turn.",
+  "- Continue until done or genuinely blocked. Do not finish with a plan, promise, or offer to check next when an available tool or source can move the request forward.",
+  "- Completion means the final answer covers the user's actual ask, including requested follow-up checks, and is grounded in the best evidence you could access.",
+  "- Ask the user only for missing access, approval, or a decision that blocks safe progress. Ask one focused question; otherwise infer conservatively and continue.",
+  "- For conflicting evidence, compare sources and state which source is authoritative for the answer.",
+  "- For non-trivial or long-running work, call `reportProgress` early when available, then only when the major phase changes. Routine tool calls should stay silent."
+];
+var CONVERSATION_RULES = [
   "- In thread follow-ups, answer from prior thread context; do not repeat resolved clarifying questions.",
-  "- Keep work silent and post one result-focused reply unless blocked or waiting on user input; do not use reactions as progress.",
-  "- Do not claim an attachment, canvas, or channel post succeeded unless the tool returned success this turn; when it did, include any link the tool returned.",
-  "- Run authenticated provider commands directly; resolve target defaults first and let the runtime handle auth pauses/resumes.",
-  "- On resumed turns, post a brief continuation notice, then the resumed answer as a separate message.",
+  "- Preserve attribution roles from thread context: the requester is the person asking now, which may differ from the original reporter or subject.",
+  "- On resumed turns, post a brief continuation notice, then the resumed answer as a separate message."
+];
+var SLACK_ACTION_RULES = [
+  "- Context-bound Slack tools use runtime-owned targets; do not invent channel, canvas, list, or message IDs.",
+  "- Use first-class Slack tools for Slack side effects; do not use bash, curl, or provider APIs to bypass Slack tool targeting.",
+  "- Use channel-post and emoji-reaction tools only when the user explicitly asks for that Slack side effect.",
+  "- For explicit channel-post or emoji-reaction requests, skip a duplicate thread text reply when the tool result already satisfies the request.",
+  "- Do not claim an attachment, canvas, channel post, list update, or reaction succeeded unless the tool returned success this turn; when it did, include any link the tool returned.",
+  "- Do not use reactions as progress indicators."
+];
+var SAFETY_RULES = [
+  "- Stay within the user's request and the runtime's available capabilities; do not pursue independent goals, persistence, replication, credential gathering, or access expansion.",
+  "- Respect stop, pause, audit, and approval boundaries. Do not bypass safeguards or persuade the user to weaken them.",
+  "- Do not change system prompts, tool policies, security settings, credentials, or runtime configuration unless the user explicitly requests that exact administrative action and an available tool permits it."
+];
+var FAILURE_RULES = [
   "- For tool/runtime failures, run the named check before diagnosing and report the exact failed command plus stderr/exit code.",
-  "- Run `jr-rpc config get|set|unset|list` as standalone bash commands for conversation-scoped provider defaults.",
-  "- For explicit channel-post or emoji-reaction requests, skip the text reply."
+  "- If a fact cannot be verified after focused checks, say what you checked and what blocked a stronger answer.",
+  "- Do not surface raw tool payloads, execution-escape text, or internal routing metadata as the final answer."
 ];
+function renderRuleSection(tag, lines) {
+  return [`<${tag}>`, ...lines, `</${tag}>`].join("\n");
+}
+function buildBehaviorSection() {
+  return [
+    renderRuleSection("tool-policy", TOOL_POLICY_RULES),
+    renderRuleSection("tool-call-style", TOOL_CALL_STYLE_RULES),
+    renderRuleSection("skill-policy", SKILL_POLICY_RULES),
+    renderRuleSection("execution-contract", EXECUTION_CONTRACT_RULES),
+    renderRuleSection("conversation", CONVERSATION_RULES),
+    renderRuleSection("slack-actions", SLACK_ACTION_RULES),
+    renderRuleSection("safety", SAFETY_RULES),
+    renderRuleSection("failure-handling", FAILURE_RULES)
+  ].join("\n\n");
+}
 function buildOutputSection() {
   const openTag = `<output format="slack-mrkdwn" max_inline_chars="${slackOutputPolicy.maxInlineChars}" max_inline_lines="${slackOutputPolicy.maxInlineLines}">`;
   return [
     openTag,
+    "- Start with the answer or result, not internal process narration.",
     "- Use Slack-friendly mrkdwn: bolded section labels instead of headings, no markdown tables or markdown links, and plain URLs.",
     "- Keep replies brief and scannable; use bullets or short code blocks when helpful, and one compact thread reply when it fits.",
-    "- When a research or document-style answer would benefit from continuation, multiple sections, or future reference value, create a Slack canvas and keep the thread reply to a short summary plus the canvas link.",
-    "- End every turn with a final user-facing markdown response.",
+    "- When a research or document-style answer would benefit from continuation, multiple sections, or future reference value, create a Slack canvas and keep the thread reply to one or two short sentences plus the link; do not recap the canvas contents.",
+    "- Unless a successful Slack side-effect tool intentionally satisfied the request by itself, end every turn with a final user-facing markdown response.",
     "</output>"
   ].join("\n");
 }
+function buildRuntimeSection(params) {
+  const lines = [
+    `- version: ${escapeXml(getRuntimeMetadata().version ?? "unknown")}`,
+    params.modelId ? `- model: ${escapeXml(params.modelId)}` : "",
+    params.fastModelId ? `- fast_model: ${escapeXml(params.fastModelId)}` : "",
+    params.thinkingLevel ? `- thinking: ${escapeXml(params.thinkingLevel)}` : "",
+    params.channelId ? "- channel: slack" : "",
+    params.channelId ? `- slack_capabilities: ${escapeXml(
+      formatSlackCapabilityNames(params.slackCapabilities)
+    )}` : "",
+    `- sandbox_workspace: ${escapeXml(SANDBOX_WORKSPACE_ROOT)}`
+  ].filter(Boolean);
+  return renderTagBlock("runtime", lines.join("\n"));
+}
 function buildContextSection(params) {
   const blocks = [];
   if (JUNIOR_WORLD) {
@@ -3070,10 +3173,6 @@ function buildContextSection(params) {
       ])
     );
   }
-  const runtimeVersion = getRuntimeMetadata().version;
-  if (runtimeVersion) {
-    blocks.push([`<runtime version="${escapeXml(runtimeVersion)}" />`]);
-  }
   blocks.push(
     renderIdentityBlock("assistant", {
       user_name: params.assistant?.userName ?? botConfig.userName,
@@ -3106,7 +3205,7 @@ function buildContextSection(params) {
   if (configLines) {
     blocks.push(
       renderTag("configuration", [
-        "Conversation-scoped defaults. Follow explicit user input when it conflicts.",
+        "Install and conversation-scoped defaults. Channel overrides take precedence; follow explicit user input when it conflicts.",
         ...configLines
       ])
     );
@@ -3145,6 +3244,13 @@ function buildSystemPrompt(params) {
   const sections = [
     HEADER,
     renderTagBlock("personality", JUNIOR_PERSONALITY.trim()),
+    renderTagBlock("behavior", buildBehaviorSection()),
+    buildOutputSection(),
+    buildCapabilitiesSection({
+      availableSkills: params.availableSkills,
+      activeSkills: params.activeSkills,
+      activeMcpCatalogs: params.activeMcpCatalogs ?? []
+    }),
     buildContextSection({
       assistant: params.assistant,
       requester: params.requester,
@@ -3154,13 +3260,7 @@ function buildSystemPrompt(params) {
       invocation: params.invocation,
       turnState: params.turnState
     }),
-    buildCapabilitiesSection({
-      availableSkills: params.availableSkills,
-      activeSkills: params.activeSkills,
-      activeMcpCatalogs: params.activeMcpCatalogs ?? []
-    }),
-    renderTagBlock("behavior", BEHAVIOR_RULES.join("\n")),
-    buildOutputSection()
+    buildRuntimeSection(params.runtime ?? {})
   ];
   return sections.join("\n\n");
 }
@@ -4808,7 +4908,7 @@ function resolveMcpArguments(input) {
 }
 function createCallMcpToolTool(mcpToolManager, getActiveSkills) {
   return tool({
-    description: "Call an active MCP tool by exact tool_name. Use loadSkill to activate the provider, then searchMcpTools to discover tool names and schemas; authorization is handled by the runtime when required.",
+    description: "Call an active MCP tool by exact tool_name. Use loadSkill to activate the provider, then searchMcpTools to discover tool names and schemas; copy required provider fields into arguments. Do not call with only tool_name unless the discovered tool has no arguments. Authorization is handled by the runtime when required.",
     inputSchema: Type4.Object(
       {
         tool_name: Type4.String({
@@ -4817,7 +4917,7 @@ function createCallMcpToolTool(mcpToolManager, getActiveSkills) {
         }),
         arguments: Type4.Optional(
           Type4.Record(Type4.String(), Type4.Unknown(), {
-            description: "Arguments matching the disclosed MCP tool schema."
+            description: 'Arguments matching the disclosed MCP tool schema, for example { "query": "..." } when searchMcpTools shows query is required.'
           })
         )
       },
@@ -4875,13 +4975,15 @@ async function loadSkillFromHost(availableSkills, skillName) {
     skill_name: skill.name,
     description: skill.description,
     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.`,
     instructions: loaded.body
   };
 }
 function createLoadSkillTool(availableSkills, options) {
   return tool({
-    description: "Load a skill by name so its instructions and provider tool catalog are available for this turn. When the result includes mcp_provider and available_tool_count, use searchMcpTools to list or search descriptors before callMcpTool. Use when a request clearly matches a known skill.",
+    description: "Load a skill by name for this turn. The result includes working_directory; resolve skill paths there and run skill-owned bash commands from there or with absolute paths. When the result includes mcp_provider, use searchMcpTools before callMcpTool. Use when a request clearly matches a known skill.",
     inputSchema: Type5.Object({
       skill_name: Type5.String({
         minLength: 1,
@@ -5694,7 +5796,7 @@ function mergeRecentCanvases(existing, created) {
 }
 function createSlackCanvasCreateTool(context, state) {
   return tool({
-    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, keep the thread reply brief and include the canvas link. Do not use for short answers that fit cleanly in one normal thread reply.",
+    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: Type12.Object({
       title: Type12.String({
         minLength: 1,
@@ -6435,25 +6537,24 @@ async function fetchWithPinnedLookup(url, resolved, signal) {
           chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
         });
         response.on("end", () => {
-          signal.removeEventListener("abort", onAbort);
-          const headers = new Headers();
-          for (const [name, value] of Object.entries(response.headers)) {
-            if (Array.isArray(value)) {
-              for (const item of value) {
-                headers.append(name, item);
-              }
-              continue;
-            }
-            if (typeof value === "string") {
-              headers.set(name, value);
+          try {
+            signal.removeEventListener("abort", onAbort);
+            const headers = new Headers();
+            const rawHeaders = response.rawHeaders;
+            for (let i = 0; i < rawHeaders.length; i += 2) {
+              headers.append(rawHeaders[i], rawHeaders[i + 1]);
             }
+            const rawStatus = response.statusCode ?? 500;
+            const status = rawStatus >= 200 && rawStatus <= 599 ? rawStatus : 502;
+            resolve(
+              new Response(Buffer.concat(chunks), {
+                status,
+                headers
+              })
+            );
+          } catch (error) {
+            reject(error);
           }
-          resolve(
-            new Response(Buffer.concat(chunks), {
-              status: response.statusCode ?? 500,
-              headers
-            })
-          );
         });
       }
     );
@@ -6544,9 +6645,7 @@ async function readResponseBody(response, maxBytes) {
     }
     chunks.push(value);
   }
-  return new TextDecoder().decode(
-    Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)))
-  );
+  return new TextDecoder().decode(Buffer.concat(chunks));
 }
 
 // src/chat/tools/web/fetch-content.ts
@@ -7484,7 +7583,17 @@ if (args.length === 0 || args[0] === "--version" || args[0] === "version") {
   process.exit(0);
 }
 
-if (args[0] === "issues" && args[1] === "list") {
+if (args[0] === "--help" || args[0] === "help") {
+  outputText("USAGE\\n  sentry issue list|view|events ...\\n  sentry org list|view ...\\n  sentry log list|view ...\\n  sentry trace list|view|logs ...\\n  sentry api ...\\n");
+  process.exit(0);
+}
+
+if (args.includes("--help")) {
+  outputText("sentry eval stub help\\n");
+  process.exit(0);
+}
+
+if (args[0] === "issue" && args[1] === "list") {
   if (hasFlag("--json")) {
     outputJson([]);
   } else {
@@ -7493,7 +7602,7 @@ if (args[0] === "issues" && args[1] === "list") {
   process.exit(0);
 }
 
-if (args[0] === "organizations" && args[1] === "list") {
+if (args[0] === "org" && args[1] === "list") {
   if (hasFlag("--json")) {
     outputJson([{ slug: "getsentry", name: "Sentry" }]);
   } else {
@@ -8948,6 +9057,8 @@ function trimTrailingAssistantMessages(messages) {
 // src/chat/services/reply-delivery-plan.ts
 var REACTION_ONLY_ACK_RE = /^(?::[a-z0-9_+-]+:|[\p{Extended_Pictographic}\uFE0F\u200D]+)$/u;
 var REDUNDANT_REACTION_ACK_TEXT = ["done", "got it", "ok", "okay"];
+var REACTION_INTENT_RE = /\b(react|reaction|emoji|thumbs?\s*up|acknowledge)\b/i;
+var REACTION_WITH_REPLY_INTENT_RE = /\b(confirm|explain|reply|respond|say|tell|summari[sz]e|why)\b/i;
 function normalizeReactionAckText(text) {
   return text.trim().toLowerCase().replace(/[!.]+$/g, "");
 }
@@ -8964,6 +9075,13 @@ function isRedundantReactionAckText(text) {
     normalized
   );
 }
+function isReactionOnlyIntent(text) {
+  const normalized = text.trim();
+  if (!normalized) {
+    return false;
+  }
+  return REACTION_INTENT_RE.test(normalized) && !REACTION_WITH_REPLY_INTENT_RE.test(normalized);
+}
 function buildReplyDeliveryPlan(args) {
   const mode = args.explicitChannelPostIntent && args.channelPostPerformed ? "channel_only" : "thread";
   let attachFiles = "none";
@@ -9024,6 +9142,22 @@ Note: No file was attached in this turn. I need to attach the file before claimi
 }
 
 // src/chat/services/turn-result.ts
+var POST_CANVAS_REPLY_MAX_CHARS = 700;
+var POST_CANVAS_REPLY_MAX_LINES = 8;
+function isVerbosePostCanvasReply(text) {
+  const lines = text.split(/\r?\n/).filter((line) => line.trim().length > 0);
+  return text.length > POST_CANVAS_REPLY_MAX_CHARS || lines.length > POST_CANVAS_REPLY_MAX_LINES;
+}
+function getCreatedCanvasUrl(artifactStatePatch) {
+  if (artifactStatePatch.lastCanvasUrl) {
+    return artifactStatePatch.lastCanvasUrl;
+  }
+  return artifactStatePatch.recentCanvases?.find((canvas) => canvas.url)?.url;
+}
+function buildBriefPostCanvasReply(artifactStatePatch) {
+  const canvasUrl = getCreatedCanvasUrl(artifactStatePatch);
+  return canvasUrl ? `I created a canvas with the full reference: ${canvasUrl}` : "I created a canvas with the full reference.";
+}
 function buildTurnResult(input) {
   const {
     newMessages,
@@ -9053,6 +9187,7 @@ function buildTurnResult(input) {
   const channelPostPerformed = successfulToolNames.has(
     "slackChannelPostMessage"
   );
+  const canvasCreated = successfulToolNames.has("slackCanvasCreate");
   const reactionPerformed = successfulToolNames.has("slackMessageAddReaction");
   const baseDeliveryPlan = buildReplyDeliveryPlan({
     explicitChannelPostIntent,
@@ -9085,7 +9220,9 @@ function buildTurnResult(input) {
   const usedPrimaryText = Boolean(primaryText);
   const outcome = primaryText ? stopReason === "error" ? "provider_error" : "success" : sideEffectOnlySuccess ? "success" : "execution_failure";
   const fallbackText = buildExecutionFailureMessage(toolErrorCount);
-  const responseText = primaryText || (sideEffectOnlySuccess ? "" : fallbackText);
+  const suppressReactionOnlyText = reactionPerformed && !channelPostPerformed && replyFiles.length === 0 && Boolean(primaryText) && isReactionOnlyIntent(userInput);
+  const rawResponseText = suppressReactionOnlyText ? "" : primaryText || (sideEffectOnlySuccess ? "" : fallbackText);
+  const responseText = canvasCreated && isVerbosePostCanvasReply(rawResponseText) ? buildBriefPostCanvasReply(artifactStatePatch) : rawResponseText;
   const escapedOrRawPayload = Boolean(primaryText) && (isExecutionEscapeResponse(primaryText) || isRawToolPayloadResponse(primaryText));
   const resolvedText = escapedOrRawPayload ? fallbackText : enforceAttachmentClaimTruth(responseText, replyFiles.length > 0);
   const deliveryPlan = reactionPerformed && !resolvedText && replyFiles.length === 0 && !channelPostPerformed ? {
@@ -9149,7 +9286,13 @@ var turnExecutionProfileSchema = z.object({
   confidence: z.number().min(0).max(1),
   reason: z.string().min(1)
 });
-var DEFAULT_THINKING_LEVEL = "low";
+var DEFAULT_THINKING_LEVEL = "medium";
+var THINKING_LEVEL_RANK = {
+  none: 0,
+  low: 1,
+  medium: 2,
+  high: 3
+};
 function trimContextForRouter(text) {
   const trimmed = text?.trim();
   if (!trimmed) {
@@ -9172,13 +9315,14 @@ function trimContextForRouter(text) {
 }
 function buildClassifierSystemPrompt() {
   return [
-    "You route assistant turns to the cheapest thinking level that is still likely to succeed.",
+    "You route assistant turns to the thinking level most likely to produce a complete, source-grounded answer.",
     "Choose exactly one bucket: none, low, medium, or high.",
     "",
-    "Use none for greetings, acknowledgments, and trivial single-step asks.",
-    "Use low for straightforward explanations or simple one-step work.",
-    "Use medium for investigations, ambiguous asks, multi-step analysis, or likely multi-tool work.",
+    "Use none only for greetings, acknowledgments, and turns that need no substantive assistant work.",
+    "Use low rarely: only for deterministic one-step answers or transformations with no tools, no current/external facts, no thread-background interpretation, and no source verification.",
+    "Use medium for normal assistant work: explanations, source-backed checks, thread follow-ups, tool choice, likely tool use, ambiguous asks, multi-step analysis, or anything where a confident but shallow answer would be risky.",
     "Use high for code changes, debugging/root-cause analysis, research-heavy work, non-trivial drafting, or explicit requests to be thorough.",
+    "When unsure between two non-none buckets, choose the higher bucket. Do not use low as the default.",
     "",
     "Classify based on the substance of the task, not the length of the current message. When the current instruction is a short affirmation (for example: 'go', 'do it', 'yes please', 'proceed') and the thread-background contains a pending task, classify the pending task \u2014 not the affirmation.",
     "",
@@ -9251,15 +9395,31 @@ async function selectTurnThinkingLevel(args) {
         },
         prompt
       });
+      const normalizedSelection = applyThinkingFloor(selection, {
+        minimum: trimmedContext || turnBlockCount > 0 ? "medium" : void 0
+      });
       setSpanAttributes({
-        "app.ai.thinking_level": selection.thinkingLevel,
-        "app.ai.thinking_level_reason": selection.reason,
-        ...selection.confidence !== void 0 ? { "app.ai.thinking_level_confidence": selection.confidence } : {}
+        "app.ai.thinking_level": normalizedSelection.thinkingLevel,
+        "app.ai.thinking_level_reason": normalizedSelection.reason,
+        ...normalizedSelection.confidence !== void 0 ? {
+          "app.ai.thinking_level_confidence": normalizedSelection.confidence
+        } : {}
       });
-      return selection;
+      return normalizedSelection;
     }
   );
 }
+function applyThinkingFloor(selection, args) {
+  const minimum = args.minimum;
+  if (!minimum || selection.thinkingLevel === "none" || THINKING_LEVEL_RANK[selection.thinkingLevel] >= THINKING_LEVEL_RANK[minimum]) {
+    return selection;
+  }
+  return {
+    ...selection,
+    thinkingLevel: minimum,
+    reason: `thinking_floor:${minimum}:${selection.reason}`
+  };
+}
 async function classifyTurn(args) {
   try {
     const result = await args.completeObject({
@@ -9278,7 +9438,7 @@ async function classifyTurn(args) {
       return {
         confidence: parsed.confidence,
         thinkingLevel: DEFAULT_THINKING_LEVEL,
-        reason: `low_confidence_default:${reason}`
+        reason: `low_confidence_medium_default:${reason}`
       };
     }
     return {
@@ -10013,6 +10173,7 @@ async function generateAssistantReply(messageText, context = {}) {
     timeoutResumeSliceId = currentSliceId;
     const persistedConfigurationValues = context.channelConfiguration ? await context.channelConfiguration.resolveValues() : {};
     configurationValues = {
+      ...getConfigDefaults(),
       ...context.configuration ?? {},
       ...persistedConfigurationValues
     };
@@ -10215,6 +10376,8 @@ async function generateAssistantReply(messageText, context = {}) {
       assistantUserName: context.assistant?.userName,
       modelId: botConfig.modelId
     });
+    const toolChannelId = context.toolChannelId ?? context.correlation?.channelId;
+    const channelCapabilities = resolveChannelCapabilities(toolChannelId);
     const tools = createTools(
       availableSkills,
       {
@@ -10268,10 +10431,8 @@ async function generateAssistantReply(messageText, context = {}) {
         }
       },
       {
-        channelId: context.toolChannelId ?? context.correlation?.channelId,
-        channelCapabilities: resolveChannelCapabilities(
-          context.toolChannelId ?? context.correlation?.channelId
-        ),
+        channelId: toolChannelId,
+        channelCapabilities,
         messageTs: context.correlation?.messageTs,
         threadTs: context.correlation?.threadTs,
         userText: userInput,
@@ -10300,6 +10461,13 @@ async function generateAssistantReply(messageText, context = {}) {
       availableSkills,
       activeSkills,
       activeMcpCatalogs,
+      runtime: {
+        channelId: toolChannelId,
+        fastModelId: botConfig.fastModelId,
+        modelId: botConfig.modelId,
+        slackCapabilities: channelCapabilities,
+        thinkingLevel: thinkingSelection.thinkingLevel
+      },
       invocation: skillInvocation,
       assistant: context.assistant,
       requester: context.requester,
@@ -15881,6 +16049,7 @@ async function createApp(options) {
   setPluginPackages(
     options?.pluginPackages ?? await resolveBuildPluginPackages()
   );
+  setConfigDefaults(options?.configDefaults);
   const waitUntil = options?.waitUntil ?? await defaultWaitUntil();
   const app = new Hono();
   app.onError((err, c) => {

package/dist/{chunk-LEYD42MR.js → chunk-3M7ZD6FF.js}

@@ -7,7 +7,7 @@ import {
   serializeGenAiAttribute,
   setSpanAttributes,
   withSpan
-} from "./chunk-RZJDO55D.js";
+} from "./chunk-XARRBRQV.js";
 
 // src/chat/state/adapter.ts
 import { createMemoryState } from "@chat-adapter/state-memory";

package/dist/{chunk-3SH2A7VQ.js → chunk-EHXMTKBA.js}

@@ -2,7 +2,7 @@ import {
   getPluginForSkillPath,
   getPluginSkillRoots,
   logWarn
-} from "./chunk-RZJDO55D.js";
+} from "./chunk-XARRBRQV.js";
 import {
   skillRoots
 } from "./chunk-XPXD3FCE.js";

package/dist/{chunk-RZJDO55D.js → chunk-XARRBRQV.js}

@@ -2725,6 +2725,9 @@ function getPluginDefinition(provider) {
 function isPluginProvider(provider) {
   return ensurePluginsLoaded().pluginsByName.has(provider);
 }
+function isPluginConfigKey(key) {
+  return ensurePluginsLoaded().pluginConfigKeys.has(key);
+}
 function createPluginBroker(provider, deps) {
   const plugin = ensurePluginsLoaded().pluginsByName.get(provider);
   if (!plugin) {
@@ -2787,5 +2790,6 @@ export {
   getPluginForSkillPath,
   getPluginDefinition,
   isPluginProvider,
+  isPluginConfigKey,
   createPluginBroker
 };

package/dist/cli/check.js

@@ -1,9 +1,9 @@
 import {
   parseSkillFile
-} from "../chunk-3SH2A7VQ.js";
+} from "../chunk-EHXMTKBA.js";
 import {
   parsePluginManifest
-} from "../chunk-RZJDO55D.js";
+} from "../chunk-XARRBRQV.js";
 import "../chunk-Z3YD6NHK.js";
 import "../chunk-XPXD3FCE.js";
 import "../chunk-2KG3PWR4.js";

package/dist/cli/snapshot-warmup.js

@@ -1,12 +1,12 @@
 import {
   disconnectStateAdapter,
   resolveRuntimeDependencySnapshot
-} from "../chunk-LEYD42MR.js";
+} from "../chunk-3M7ZD6FF.js";
 import {
   getPluginProviders,
   getPluginRuntimeDependencies,
   getPluginRuntimePostinstall
-} from "../chunk-RZJDO55D.js";
+} from "../chunk-XARRBRQV.js";
 import "../chunk-Z3YD6NHK.js";
 import "../chunk-XPXD3FCE.js";
 import "../chunk-2KG3PWR4.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior",
-  "version": "0.31.0",
+  "version": "0.32.0",
   "private": false,
   "publishConfig": {
     "access": "public"