@sentry/junior 0.30.0 → 0.32.0

package/dist/app.js

@@ -2,9 +2,8 @@ import {
   discoverSkills,
   findSkillByName,
   loadSkillsByName,
-  logCapabilityCatalogLoadedOnce,
   parseSkillInvocation
-} from "./chunk-ICIRAL6Y.js";
+} from "./chunk-EHXMTKBA.js";
 import {
   GEN_AI_PROVIDER_NAME,
   MISSING_GATEWAY_CREDENTIALS_ERROR,
@@ -31,7 +30,7 @@ import {
   runNonInteractiveCommand,
   sandboxSkillDir,
   sandboxSkillFile
-} from "./chunk-LEYD42MR.js";
+} from "./chunk-3M7ZD6FF.js";
 import {
   CredentialUnavailableError,
   buildOAuthTokenRequest,
@@ -40,11 +39,14 @@ import {
   createRequestContext,
   extractGenAiUsageSummary,
   getActiveTraceId,
+  getPluginCapabilityProviders,
+  getPluginCatalogSignature,
   getPluginDefinition,
   getPluginMcpProviders,
   getPluginOAuthConfig,
   getPluginProviders,
   hasRequiredOAuthScope,
+  isPluginConfigKey,
   isPluginProvider,
   isRecord,
   logError,
@@ -62,7 +64,7 @@ import {
   toOptionalString,
   withContext,
   withSpan
-} from "./chunk-RZJDO55D.js";
+} from "./chunk-XARRBRQV.js";
 import "./chunk-Z3YD6NHK.js";
 import {
   discoverInstalledPluginPackageContent,
@@ -77,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";
@@ -2883,18 +2905,21 @@ function formatConfigurationValue(value) {
 function renderIdentityBlock(tag, fields) {
   const lines = Object.entries(fields).filter(([, value]) => Boolean(value)).map(([key, value]) => `- ${key}: ${escapeXml(value)}`);
   if (lines.length === 0) {
-    return [`<${tag}>`, "none", `</${tag}>`].join("\n");
+    return [`<${tag}>`, "none", `</${tag}>`];
   }
-  return [`<${tag}>`, ...lines, `</${tag}>`].join("\n");
+  return [`<${tag}>`, ...lines, `</${tag}>`];
 }
-function renderTag(tag, content) {
+function renderTag(tag, lines) {
+  return [`<${tag}>`, ...lines, `</${tag}>`];
+}
+function renderTagBlock(tag, content) {
   return [`<${tag}>`, content, `</${tag}>`].join("\n");
 }
 function formatAvailableSkillsForPrompt(skills) {
   if (skills.length === 0) {
-    return "<available_skills>\n</available_skills>";
+    return "<available-skills>\n</available-skills>";
   }
-  const lines = ["<available_skills>"];
+  const lines = ["<available-skills>"];
   for (const skill of skills) {
     const skillLocation = `${workspaceSkillDir(skill.name)}/SKILL.md`;
     lines.push("  <skill>");
@@ -2906,45 +2931,39 @@ function formatAvailableSkillsForPrompt(skills) {
     if (skill.pluginProvider) {
       lines.push(`    <provider>${escapeXml(skill.pluginProvider)}</provider>`);
     }
-    if (skill.usesConfig && skill.usesConfig.length > 0) {
-      lines.push(
-        `    <uses_config>${escapeXml(skill.usesConfig.join(" "))}</uses_config>`
-      );
-    }
     lines.push("  </skill>");
   }
-  lines.push("</available_skills>");
+  lines.push("</available-skills>");
   return lines.join("\n");
 }
 function formatLoadedSkillsForPrompt(skills) {
   if (skills.length === 0) {
-    return "<loaded_skills>\n</loaded_skills>";
+    return "<loaded-skills>\n</loaded-skills>";
   }
-  const lines = ["<loaded_skills>"];
+  const lines = ["<loaded-skills>"];
   for (const skill of skills) {
     const skillDir = workspaceSkillDir(skill.name);
     lines.push(
       `  <skill name="${escapeXml(skill.name)}" location="${escapeXml(`${skillDir}/SKILL.md`)}">`
     );
-    lines.push(`References are relative to ${escapeXml(skillDir)}.`);
-    if (skill.usesConfig && skill.usesConfig.length > 0) {
-      lines.push(
-        `Uses config keys: ${escapeXml(skill.usesConfig.join(", "))}.`
-      );
-    }
+    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>");
   }
-  lines.push("</loaded_skills>");
+  lines.push("</loaded-skills>");
   return lines.join("\n");
 }
 function formatProviderCatalogForPrompt() {
   const providers = getPluginProviders().map((plugin) => plugin.manifest);
   if (providers.length === 0) {
-    return "- none";
+    return null;
   }
-  const lines = [];
+  const lines = [
+    "Config keys and default targets per provider; use after a skill is loaded."
+  ];
   for (const provider of providers) {
     lines.push(`- provider: ${escapeXml(provider.name)}`);
     lines.push(
@@ -2958,288 +2977,337 @@ function formatProviderCatalogForPrompt() {
   }
   return lines.join("\n");
 }
-function baseSystemPrompt() {
-  return [
-    "You are a Slack-based helper assistant.",
-    "Identity, tone, and domain defaults are defined in the personality block.",
-    "",
-    "- Be concise, practical, and specific.",
-    "- Prefer actionable next steps over generic explanations.",
-    "- When the user gives a clear task, execute it immediately in this turn.",
-    "- Do not ask for permission to proceed when the request is already clear.",
-    "- Keep user-visible progress communication concise and useful.",
-    "- In thread follow-ups, answer using prior thread context directly; do not repeat unresolved clarifying questions unless the user asks to refine.",
-    "- If the user asks what you just said or means by the previous answer, summarize your prior assistant reply plainly.",
-    "- Never ask the user to re-tag or re-invoke for a clear task; continue execution in this turn.",
-    "- Never claim you cannot access tools in this turn. If prior results are empty, run tools now.",
-    "- If critical input is missing and cannot be discovered with tools, ask one direct clarifying question.",
-    "- Always gather evidence from available sources (tools or skills) before answering factual questions.",
-    "- When a loaded skill exposes MCP capabilities, those tools are registered as callable tools. Call them directly by name.",
-    "- Use `searchTools` only when you need to rediscover or filter active MCP tools.",
-    "- Never guess. If you cannot verify with available sources, say it is unverified.",
-    "- Never claim a lookup succeeded unless a tool result supports it.",
-    "- Do not give up when unsure how to do something; find a viable path, gather evidence, and provide the best actionable way forward.",
-    "- When active skills are present, follow their instructions before default behavior."
-  ].join("\n");
+function formatActiveMcpCatalogsForPrompt(catalogs) {
+  if (catalogs.length === 0) {
+    return null;
+  }
+  const lines = [
+    "Active MCP provider catalogs are available through `searchMcpTools`. Call it with provider to list descriptors or with query to narrow results, then pass the exact returned `tool_name` to `callMcpTool`."
+  ];
+  for (const catalog of catalogs) {
+    lines.push("  <catalog>");
+    lines.push(`    <provider>${escapeXml(catalog.provider)}</provider>`);
+    lines.push(
+      `    <available_tool_count>${catalog.available_tool_count}</available_tool_count>`
+    );
+    lines.push("  </catalog>");
+  }
+  return lines.join("\n");
 }
-function formatReferenceFilesSection() {
+function formatReferenceFilesLines() {
   const files = listReferenceFiles();
   if (files.length === 0) {
-    return [];
+    return null;
   }
-  const fileNames = files.map((filePath) => {
+  return files.map((filePath) => {
     const name = path2.basename(filePath);
     return `- ${escapeXml(name)} (${escapeXml(`${SANDBOX_DATA_ROOT}/${name}`)})`;
   });
-  return [
-    renderTag(
-      "reference-files",
-      [
-        "Additional reference documents available in the sandbox. Read them with `readFile` when relevant.",
-        ...fileNames
-      ].join("\n")
-    )
-  ];
 }
-function buildSystemPrompt(params) {
-  const {
-    availableSkills,
-    activeSkills,
-    activeTools,
-    invocation,
-    requester,
-    assistant,
-    artifactState,
-    configuration,
-    relevantConfigurationKeys,
-    runtimeMetadata,
-    threadParticipants
-  } = params;
-  const assistantSection = renderIdentityBlock("assistant", {
-    user_name: assistant?.userName ?? botConfig.userName,
-    user_id: assistant?.userId
-  });
-  const requesterSection = renderIdentityBlock("requester", {
-    full_name: requester?.fullName,
-    user_name: requester?.userName,
-    user_id: requester?.userId
-  });
-  const availableSkillsSection = [
-    "The following skills provide specialized instructions for specific tasks.",
-    "Call `loadSkill` when the task matches a skill description.",
-    "When a skill references a relative path, resolve it against `skill_dir` and use that path with `bash`.",
-    "",
-    formatAvailableSkillsForPrompt(availableSkills)
-  ].join("\n");
-  const activeSkillsSection = [
-    "Loaded skills for this turn:",
-    formatLoadedSkillsForPrompt(activeSkills)
-  ].join("\n");
-  const activeToolNames = (activeTools ?? []).map((tool2) => tool2.tool_name);
-  const activeToolsSection = activeToolNames.length > 0 ? `Active MCP tools registered for this turn: ${activeToolNames.join(", ")}. Call them directly by name.` : "";
-  const configurationKeys = Object.keys(configuration ?? {}).sort(
+function formatArtifactsLines(artifactState) {
+  if (!artifactState) return null;
+  const lines = [];
+  if (artifactState.lastCanvasId) {
+    lines.push(`- last_canvas_id: ${escapeXml(artifactState.lastCanvasId)}`);
+  }
+  if (artifactState.lastCanvasUrl) {
+    lines.push(`- last_canvas_url: ${escapeXml(artifactState.lastCanvasUrl)}`);
+  }
+  if (artifactState.recentCanvases && artifactState.recentCanvases.length > 0) {
+    lines.push("- recent_canvases:");
+    for (const canvas of artifactState.recentCanvases) {
+      lines.push(`  - id: ${escapeXml(canvas.id)}`);
+      if (canvas.title) lines.push(`    title: ${escapeXml(canvas.title)}`);
+      if (canvas.url) lines.push(`    url: ${escapeXml(canvas.url)}`);
+      if (canvas.createdAt) {
+        lines.push(`    created_at: ${escapeXml(canvas.createdAt)}`);
+      }
+    }
+  }
+  if (artifactState.lastListId) {
+    lines.push(`- last_list_id: ${escapeXml(artifactState.lastListId)}`);
+  }
+  if (artifactState.lastListUrl) {
+    lines.push(`- last_list_url: ${escapeXml(artifactState.lastListUrl)}`);
+  }
+  return lines.length > 0 ? lines : null;
+}
+function formatConfigurationLines(configuration) {
+  const keys = Object.keys(configuration ?? {}).sort(
     (a, b) => a.localeCompare(b)
   );
-  const relevantConfigSet = new Set(
-    (relevantConfigurationKeys ?? []).filter(
-      (key) => Object.prototype.hasOwnProperty.call(configuration ?? {}, key)
-    )
+  if (keys.length === 0) return null;
+  return keys.map(
+    (key) => `- ${escapeXml(key)}: ${formatConfigurationValue(configuration?.[key])}`
+  );
+}
+function formatThreadParticipantsLines(participants) {
+  if (!participants || participants.length === 0) return null;
+  return participants.map((p) => {
+    const parts = [];
+    if (p.userId) {
+      parts.push(`user_id: ${escapeXml(p.userId)}`);
+      parts.push(`slack_mention: <@${p.userId}>`);
+    }
+    if (p.userName) parts.push(`user_name: ${escapeXml(p.userName)}`);
+    if (p.fullName) parts.push(`full_name: ${escapeXml(p.fullName)}`);
+    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 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.",
+  "- 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.",
+  "- 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 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) {
+    blocks.push(renderTag("world", [JUNIOR_WORLD.trim()]));
+  }
+  const referenceLines = formatReferenceFilesLines();
+  if (referenceLines) {
+    blocks.push(
+      renderTag("reference-files", [
+        "Additional reference documents available in the sandbox. Read them with `readFile` when relevant.",
+        ...referenceLines
+      ])
+    );
+  }
+  blocks.push(
+    renderIdentityBlock("assistant", {
+      user_name: params.assistant?.userName ?? botConfig.userName,
+      user_id: params.assistant?.userId
+    })
   );
-  const relevantConfigLines = configurationKeys.filter((key) => relevantConfigSet.has(key)).map(
-    (key) => `  - ${escapeXml(key)}: ${formatConfigurationValue(configuration?.[key])}`
+  blocks.push(
+    renderIdentityBlock("requester", {
+      full_name: params.requester?.fullName,
+      user_name: params.requester?.userName,
+      user_id: params.requester?.userId
+    })
   );
-  const otherConfigLines = configurationKeys.filter((key) => !relevantConfigSet.has(key)).map(
-    (key) => `  - ${escapeXml(key)}: ${formatConfigurationValue(configuration?.[key])}`
+  const participantLines = formatThreadParticipantsLines(
+    params.threadParticipants
   );
-  const configurationSection = [
-    "Use these conversation-scoped defaults when the user has not provided explicit values in this turn.",
-    "If explicit user input conflicts with configuration, follow explicit user input.",
-    configurationKeys.length === 0 ? "- none" : [
-      ...relevantConfigLines.length > 0 ? ["- relevant_for_active_skills:", ...relevantConfigLines] : [],
-      ...otherConfigLines.length > 0 ? ["- other_available_keys:", ...otherConfigLines] : []
-    ].join("\n")
-  ].join("\n");
+  if (participantLines) {
+    blocks.push(
+      renderTag("thread-participants", [
+        "Known participants. When you mention one of these people, use the provided `<@USERID>` token exactly; do not write a bare `@name`.",
+        ...participantLines
+      ])
+    );
+  }
+  const artifactLines = formatArtifactsLines(params.artifactState);
+  if (artifactLines) {
+    blocks.push(renderTag("artifacts", artifactLines));
+  }
+  const configLines = formatConfigurationLines(params.configuration);
+  if (configLines) {
+    blocks.push(
+      renderTag("configuration", [
+        "Install and conversation-scoped defaults. Channel overrides take precedence; follow explicit user input when it conflicts.",
+        ...configLines
+      ])
+    );
+  }
+  if (params.turnState === "resumed") {
+    blocks.push([
+      "<turn-state>resumed</turn-state>",
+      "This turn continues from a prior checkpoint. Prior tool results and assistant messages are already in the conversation history."
+    ]);
+  }
+  if (params.invocation) {
+    blocks.push([
+      `<explicit-skill-trigger>/${escapeXml(params.invocation.skillName)}</explicit-skill-trigger>`
+    ]);
+  }
+  const body = blocks.map((block) => block.join("\n")).join("\n\n");
+  return renderTagBlock("context", body);
+}
+function buildCapabilitiesSection(params) {
+  const blocks = [];
+  blocks.push(formatAvailableSkillsForPrompt(params.availableSkills));
+  blocks.push(formatLoadedSkillsForPrompt(params.activeSkills));
+  const activeCatalogs = formatActiveMcpCatalogsForPrompt(
+    params.activeMcpCatalogs
+  );
+  if (activeCatalogs) {
+    blocks.push(renderTagBlock("active-mcp-catalogs", activeCatalogs));
+  }
+  const providerCatalog = formatProviderCatalogForPrompt();
+  if (providerCatalog) {
+    blocks.push(renderTagBlock("providers", providerCatalog));
+  }
+  return renderTagBlock("capabilities", blocks.join("\n\n"));
+}
+function buildSystemPrompt(params) {
   const sections = [
-    baseSystemPrompt(),
-    renderTag(
-      "personality",
-      [
-        "Always follow the personality guidance for tone/style unless safety or policy constraints require otherwise.",
-        "",
-        JUNIOR_PERSONALITY.trim()
-      ].join("\n")
-    ),
-    ...JUNIOR_WORLD ? [
-      renderTag(
-        "world",
-        [
-          "Use this as the assistant's operational/domain context.",
-          "",
-          JUNIOR_WORLD.trim()
-        ].join("\n")
-      )
-    ] : [],
-    ...formatReferenceFilesSection(),
-    renderTag(
-      "identity-context",
-      [
-        "Use these blocks as authoritative metadata for identity questions.",
-        assistantSection,
-        requesterSection,
-        ...threadParticipants && threadParticipants.length > 0 ? [
-          renderTag(
-            "thread-participants",
-            [
-              "Known participants in this thread. When you mention one of these people, use the provided Slack mention token exactly as `<@USERID>` and do not write a bare `@name` form.",
-              ...threadParticipants.map((p) => {
-                const parts = [];
-                if (p.userId) {
-                  parts.push(`user_id: ${escapeXml(p.userId)}`);
-                  parts.push(`slack_mention: <@${p.userId}>`);
-                }
-                if (p.userName)
-                  parts.push(`user_name: ${escapeXml(p.userName)}`);
-                if (p.fullName)
-                  parts.push(`full_name: ${escapeXml(p.fullName)}`);
-                return `- ${parts.join(", ")}`;
-              })
-            ].join("\n")
-          )
-        ] : []
-      ].join("\n")
-    ),
-    renderTag(
-      "artifact-context",
-      [
-        "Use this thread-scoped memory for follow-up updates to existing Slack artifacts.",
-        artifactState ? [
-          artifactState.lastCanvasId ? `- last_canvas_id: ${escapeXml(artifactState.lastCanvasId)}` : "- last_canvas_id: none",
-          artifactState.lastCanvasUrl ? `- last_canvas_url: ${escapeXml(artifactState.lastCanvasUrl)}` : "- last_canvas_url: none",
-          artifactState.recentCanvases && artifactState.recentCanvases.length > 0 ? [
-            "- recent_canvases:",
-            ...artifactState.recentCanvases.map(
-              (canvas) => [
-                `  - id: ${escapeXml(canvas.id)}`,
-                canvas.title ? `    title: ${escapeXml(canvas.title)}` : "    title: [unknown]",
-                canvas.url ? `    url: ${escapeXml(canvas.url)}` : "    url: [unknown]",
-                canvas.createdAt ? `    created_at: ${escapeXml(canvas.createdAt)}` : "    created_at: [unknown]"
-              ].join("\n")
-            )
-          ].join("\n") : "- recent_canvases: none",
-          artifactState.lastListId ? `- last_list_id: ${escapeXml(artifactState.lastListId)}` : "- last_list_id: none",
-          artifactState.lastListUrl ? `- last_list_url: ${escapeXml(artifactState.lastListUrl)}` : "- last_list_url: none"
-        ].join("\n") : "- none"
-      ].join("\n")
-    ),
-    renderTag("configuration-context", configurationSection),
-    renderTag(
-      "runtime-metadata",
-      [
-        "Use this for runtime version questions about the deployed assistant.",
-        `- version: ${escapeXml(runtimeMetadata?.version ?? "unknown")}`
-      ].join("\n")
-    ),
-    renderTag(
-      "provider-config",
-      [
-        "Use this catalog to map already-chosen provider work to valid config keys and provider defaults.",
-        "Do not use this catalog by itself to decide which domain skill matches an operational task.",
-        "When user intent is to set a provider default, choose a config key from this catalog and use jr-rpc config set.",
-        "The `jr-rpc` config command is a built-in bash custom command when conversation config is available; do not claim it is missing just because no `jr-rpc` skill is loaded.",
-        formatProviderCatalogForPrompt()
-      ].join("\n")
-    ),
-    renderTag(
-      "skill-routing",
-      [
-        "- Choose the skill that matches the requested operation, not incidental nouns, product names, organization names, or channel context.",
-        "- When multiple skills seem adjacent, prefer the one whose description matches the user's requested action most directly.",
-        "- If the task needs evidence from a specialized external system or workflow, load the matching skill before drawing conclusions.",
-        "- The provider-config catalog is for exact config keys and provider defaults after skill selection. It is not a shortcut for choosing a domain.",
-        "- Never start provider auth speculatively. First load the skill that owns the operation, then let runtime-managed credential injection handle authenticated provider commands for that skill."
-      ].join("\n")
-    ),
-    renderTag(
-      "tool-usage",
-      [
-        "- For factual or external questions, run tools/skills first, then answer from evidence.",
-        "- Use tool descriptions as the source of truth for when each tool should or should not be called.",
-        "- When using CLI tools through `bash`, prefer deterministic non-interactive flags and avoid commands that wait for prompts or editors.",
-        "- Keep routine setup and research steps silent in user-facing replies. Do not narrate duplicate checks, credential issuance, file writes, or similar internal progress unless the result is user-relevant.",
-        "- If a routine prerequisite check finds nothing notable, omit it entirely from the final reply and report only the user-relevant outcome.",
-        "- Prefer a single result-focused reply after tool work completes. Only send an interim reply when you need user input or have a concrete blocking problem to report.",
-        "- For external/factual research requests that require tools, do not send any preliminary conclusion, 'let me check', or progress narration before the evidence-gathering work is done. Use assistant status for in-progress work and make the first visible reply the researched answer.",
-        "- For evidence-gathering tasks, never state a factual conclusion before you have actually gathered and checked the sources.",
-        "- When the user provides multiple sources, synthesize them explicitly as one combined answer instead of anchoring the reply on a single page or API call.",
-        "- When the user provides explicit URLs or named sources, briefly anchor the answer to those provided sources (for example, 'Across the provided Slack docs...') so the summary reads as researched rather than generic memory.",
-        "- Do not include internal process chatter such as 'let me find', 'fetching now', 'good, I have sources', 'trying smaller limits', or 'I now have sufficient context' in the final user-facing reply.",
-        "- Never claim a screenshot/file is attached unless `attachFile` succeeded in this turn.",
-        "- If `attachFile` fails, explain the failure and do not say the file was shared.",
-        "- When you create or update a Slack artifact in this turn (for example a canvas, list, posted message, or attached file), mention it explicitly in the final reply and include its link when the tool returned one.",
-        "- For explicit in-channel post requests, prefer no thread text reply after a successful channel post. A reaction-only acknowledgment is acceptable when useful.",
-        "- When the user explicitly asks for an emoji reaction instead of text, react and skip the text reply.",
-        "- After the matching plugin-owned skill is loaded, authenticated bash commands for that skill get provider credentials injected automatically for the current turn.",
-        "- Resolve repo/project/org defaults before authenticated provider commands so the runtime can narrow injected credentials correctly.",
-        "- If no loaded skill clearly owns the authenticated command, load the matching skill first instead of guessing from the provider catalog.",
-        "- If provider authorization is required, the runtime sends the private authorization link itself and resumes the paused turn after authorization.",
-        "- Do not try to manage provider auth directly. Run the real provider command and let the runtime handle authorization, reconnect, and resume behavior.",
-        "- Provider-targeted commands may need `--target <value>` or a provider-specific configured default target key when the provider catalog shows one.",
-        "- To persist or read conversation defaults, choose a config key from the provider catalog or active skill metadata and run `jr-rpc config get|set|unset|list ...` as a bash command.",
-        "- `jr-rpc` config commands are built into the bash runtime for conversation-scoped config work; they do not require a separate helper binary in the sandbox.",
-        "- When your work is complete, provide the exact user-facing markdown response.",
-        "- Do not use reaction-based progress signals; Assistants API status already covers in-progress UX.",
-        "- Never call side-effecting tools when the user only asked for analysis or options.",
-        "- When the user asks for their conversation ID, trace ID, or a reference for Sentry lookup, use the IDs from `<session-context>` and `<turn-context>` in the user turn."
-      ].join("\n")
-    ),
-    renderTag(
-      "skills",
-      [
-        "- Explicit skill triggers may appear as `/skillname`.",
-        "- If explicitly invoked skill instructions are already present in <loaded_skills>, apply them immediately.",
-        "- If an explicitly invoked skill is present in <loaded_skills>, never say the skill is unavailable, missing, or unsupported in this environment.",
-        "- Otherwise, for an explicitly invoked skill, call `loadSkill` for that exact skill before applying skill-specific behavior.",
-        "- For requests without an explicit trigger where a skill clearly matches, call `loadSkill` before applying skill-specific behavior.",
-        "- When multiple skills appear relevant, prefer the skill whose description best matches the requested action rather than incidental domain nouns in the prompt.",
-        "- For explicit config tasks, you may load the helper skill that owns config commands, but do not use helper skills to choose the provider for unrelated operational work.",
-        "- Do not claim to have used a skill unless it is present in <loaded_skills> or `loadSkill` succeeded in this turn.",
-        "- Never apply skill-specific behavior unless the skill is present in <loaded_skills> or `loadSkill` succeeded in this turn.",
-        "- Load only the best matching skill first; do not load multiple skills upfront.",
-        "- After `loadSkill`, use `skill_dir` as the root for any referenced files you read via `bash`.",
-        "- If a loaded skill exposes MCP tools, they are registered as callable tools after `loadSkill` returns. Call them directly by name (for example `mcp__provider__tool_name`).",
-        "- If no skill is a clear fit, continue with normal tool usage."
-      ].join("\n")
-    ),
-    renderTag(
-      "output-contract",
-      [
-        "Always produce output that follows this contract:",
-        `<output format="slack-mrkdwn" max_inline_chars="${slackOutputPolicy.maxInlineChars}" max_inline_lines="${slackOutputPolicy.maxInlineLines}">`,
-        "- Use Slack-friendly markdown, not full CommonMark. Prefer bold section labels over markdown headings, and use bullets and short code blocks when helpful.",
-        "- Keep normal responses brief and scannable.",
-        "- If depth is needed, start with a concise summary and then provide fuller detail.",
-        "- Prefer a single compact thread reply when the full answer comfortably fits within this inline budget.",
-        "- When canvas creation is available and a research or document-style answer would likely need continuation, multiple sections, or future reference value, create a Slack canvas and keep the thread reply to a short summary plus the canvas link.",
-        "- Typical canvas-first cases include long-form research summaries, timelines, bios or profiles, structured notes, plans, comparisons, and other reusable reference documents.",
-        "- Do not create a canvas for short factual answers that fit cleanly in one normal thread reply.",
-        "- For tool-heavy research, discovery, or source-checking requests, do not send an initial acknowledgment. Start the visible reply only once you can present the actual answer.",
-        "- Do not narrate tool execution or repeated status updates in the visible reply.",
-        "- Avoid tables and markdown links like `[label](url)` unless explicitly requested. Prefer plain URLs or Slack-native entities when exact rendering matters.",
-        "- End every turn with a final user-facing markdown response.",
-        "</output>"
-      ].join("\n")
-    ),
-    availableSkillsSection,
-    activeSkillsSection,
-    ...activeToolsSection ? [activeToolsSection] : [],
-    renderTag(
-      "invocation-context",
-      invocation ? `Explicit skill trigger detected: /${invocation.skillName}` : "No explicit skill trigger detected."
-    )
+    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,
+      artifactState: params.artifactState,
+      configuration: params.configuration,
+      threadParticipants: params.threadParticipants,
+      invocation: params.invocation,
+      turnState: params.turnState
+    }),
+    buildRuntimeSection(params.runtime ?? {})
   ];
   return sections.join("\n\n");
 }
 
+// src/chat/capabilities/catalog.ts
+var cachedCatalog;
+function getCapabilityCatalog() {
+  const signature = getPluginCatalogSignature();
+  if (cachedCatalog?.signature === signature) return cachedCatalog;
+  const providers = getPluginCapabilityProviders();
+  const capabilityToProvider = /* @__PURE__ */ new Map();
+  for (const provider of providers) {
+    for (const capability of provider.capabilities) {
+      if (capabilityToProvider.has(capability)) {
+        throw new Error(
+          `Duplicate capability registration for "${capability}"`
+        );
+      }
+      capabilityToProvider.set(capability, provider);
+    }
+  }
+  cachedCatalog = { signature, providers, capabilityToProvider };
+  return cachedCatalog;
+}
+var catalogLogged = false;
+function logCapabilityCatalogLoadedOnce() {
+  if (catalogLogged) return;
+  catalogLogged = true;
+  const { providers } = getCapabilityCatalog();
+  const capabilityNames = providers.flatMap((p) => p.capabilities).sort();
+  const configKeys = [
+    ...new Set(providers.flatMap((p) => p.configKeys))
+  ].sort();
+  logInfo(
+    "capability_catalog_loaded",
+    {},
+    {
+      "app.capability.providers": providers.map((p) => p.provider),
+      "app.capability.count": capabilityNames.length,
+      "app.capability.names": capabilityNames,
+      "app.config.key_count": configKeys.length,
+      "app.config.keys": configKeys
+    },
+    "Loaded capability provider catalog"
+  );
+}
+
 // src/chat/capabilities/router.ts
 var ProviderCredentialRouter = class {
   brokersByProvider;
@@ -3965,6 +4033,27 @@ var MCP_CLIENT_INFO = {
   name: "junior-mcp-client",
   version: "1.0.0"
 };
+var MCP_TOOLS_CALL_METHOD = "tools/call";
+function getDefaultPort(url) {
+  if (url.protocol === "https:") {
+    return 443;
+  }
+  if (url.protocol === "http:") {
+    return 80;
+  }
+  return void 0;
+}
+function getMcpNetworkAttributes(url) {
+  const port = url.port ? Number(url.port) : getDefaultPort(url);
+  return {
+    "server.address": url.hostname,
+    ...port !== void 0 ? { "server.port": port } : {},
+    ...url.protocol === "http:" || url.protocol === "https:" ? {
+      "network.protocol.name": "http",
+      "network.transport": "tcp"
+    } : {}
+  };
+}
 var McpAuthorizationRequiredError = class extends Error {
   provider;
   constructor(provider, message) {
@@ -4014,10 +4103,22 @@ var PluginMcpClient = class {
   async callTool(name, args) {
     return await this.withSessionRecovery(async () => {
       const client2 = await this.getClient();
+      const mcp = this.plugin.manifest.mcp;
+      if (mcp) {
+        const url = new URL(mcp.url);
+        setSpanAttributes({
+          "mcp.method.name": MCP_TOOLS_CALL_METHOD,
+          "gen_ai.operation.name": "execute_tool",
+          "gen_ai.tool.name": name,
+          ...this.transport?.sessionId ? { "mcp.session.id": this.transport.sessionId } : {},
+          ...this.transport?.protocolVersion ? { "mcp.protocol.version": this.transport.protocolVersion } : {},
+          ...getMcpNetworkAttributes(url)
+        });
+      }
       const result = await this.wrapAuth(
         client2.callTool({
           name,
-          ...args && Object.keys(args).length > 0 ? { arguments: args } : {}
+          arguments: args ?? {}
         })
       );
       await this.syncTransportSessionId();
@@ -4130,13 +4231,24 @@ var PluginMcpClient = class {
   }
 };
 
-// src/chat/mcp/tool-manager.ts
+// 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);
+}
+
+// src/chat/mcp/tool-manager.ts
 function normalizeMcpToolName(provider, toolName) {
   return `mcp__${provider}__${toolName}`;
 }
@@ -4302,24 +4414,6 @@ var McpToolManager = class {
       (tool2) => this.toToolDescriptor(tool2)
     );
   }
-  searchTools(skills, query, options = {}) {
-    const resolved = this.getResolvedActiveTools(skills, options);
-    const trimmedQuery = query.trim();
-    if (!trimmedQuery || trimmedQuery === "*") {
-      return resolved.slice(0, Math.max(1, options.limit ?? 8)).map((tool2) => this.toToolDescriptor(tool2));
-    }
-    const normalizedQuery = trimmedQuery.toLowerCase();
-    const queryTokens = normalizedQuery.split(/\s+/).map((token) => token.trim()).filter((token) => token.length > 0);
-    return resolved.map((tool2) => ({
-      tool: tool2,
-      score: this.scoreToolMatch(tool2, normalizedQuery, queryTokens)
-    })).filter((entry) => entry.score > 0).sort((left, right) => {
-      if (right.score !== left.score) {
-        return right.score - left.score;
-      }
-      return left.tool.name.localeCompare(right.tool.name);
-    }).slice(0, Math.max(1, options.limit ?? 8)).map((entry) => this.toToolDescriptor(entry.tool));
-  }
   filterListedTools(plugin, tools) {
     const allowedTools = plugin.manifest.mcp?.allowedTools;
     if (!allowedTools || allowedTools.length === 0) {
@@ -4351,6 +4445,8 @@ var McpToolManager = class {
     return client2;
   }
   toManagedTool(plugin, client2, tool2) {
+    const outputSchema = toOptionalRecord(tool2.outputSchema);
+    const annotations = toOptionalRecord(tool2.annotations);
     return {
       name: normalizeMcpToolName(plugin.manifest.name, tool2.name),
       description: describeMcpTool(plugin.manifest.name, tool2),
@@ -4358,8 +4454,15 @@ var McpToolManager = class {
       provider: plugin.manifest.name,
       rawName: tool2.name,
       ...tool2.title?.trim() ? { title: tool2.title.trim() } : {},
+      ...outputSchema ? { outputSchema } : {},
+      ...annotations ? { annotations } : {},
       execute: async (args) => {
         const resolvedArgs = typeof args === "object" && args !== null ? args : {};
+        const baseAttributes = {
+          "gen_ai.tool.name": tool2.name,
+          "mcp.method.name": "tools/call"
+        };
+        setSpanAttributes(baseAttributes);
         try {
           const result = await client2.callTool(tool2.name, resolvedArgs);
           if ("isError" in result && result.isError) {
@@ -4395,6 +4498,20 @@ var McpToolManager = class {
               }
             };
           }
+          const errorAttributes = {
+            ...baseAttributes,
+            "error.type": getMcpAwareErrorType(error, "mcp_tool_error"),
+            "error.message": getMcpAwareErrorMessage(error)
+          };
+          setSpanAttributes(errorAttributes);
+          if (error instanceof McpToolError) {
+            logWarn(
+              "mcp_tool_call_failed",
+              {},
+              errorAttributes,
+              "MCP tool call failed"
+            );
+          }
           throw error;
         }
       }
@@ -4441,37 +4558,19 @@ var McpToolManager = class {
   toToolDescriptor(tool2) {
     return {
       name: tool2.name,
+      rawName: tool2.rawName,
+      ...tool2.title ? { title: tool2.title } : {},
       description: tool2.description,
       parameters: tool2.parameters,
+      ...tool2.outputSchema ? { outputSchema: tool2.outputSchema } : {},
+      ...tool2.annotations ? { annotations: tool2.annotations } : {},
       provider: tool2.provider
     };
   }
-  scoreToolMatch(tool2, normalizedQuery, queryTokens) {
-    const exactCandidates = [tool2.name, tool2.rawName, tool2.title].filter((value) => Boolean(value)).map((value) => value.toLowerCase());
-    if (exactCandidates.includes(normalizedQuery)) {
-      return 100;
-    }
-    let score = 0;
-    const searchableText = [
-      tool2.name,
-      tool2.rawName,
-      tool2.title,
-      tool2.description,
-      tool2.provider
-    ].filter((value) => Boolean(value)).join(" ").toLowerCase();
-    for (const candidate of exactCandidates) {
-      if (candidate.startsWith(normalizedQuery)) {
-        score = Math.max(score, 60);
-      }
-    }
-    for (const token of queryTokens) {
-      if (searchableText.includes(token)) {
-        score += 10;
-      }
-    }
-    return score;
-  }
 };
+function toOptionalRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
 
 // src/chat/tools/definition.ts
 function tool(definition) {
@@ -4784,8 +4883,61 @@ function createImageGenerateTool(hooks, deps = {}) {
   });
 }
 
-// src/chat/tools/skill/load-skill.ts
+// src/chat/tools/skill/call-mcp-tool.ts
 import { Type as Type4 } from "@sinclair/typebox";
+function resolveMcpArguments(input) {
+  const extraKeys = Object.keys(input).filter(
+    (key) => key !== "tool_name" && key !== "arguments"
+  );
+  if (extraKeys.length > 0) {
+    throw new Error(
+      `callMcpTool MCP arguments must be nested under arguments, not top-level fields: ${extraKeys.join(", ")}`
+    );
+  }
+  if ("arguments" in input) {
+    const args = input.arguments;
+    if (args === void 0) {
+      return {};
+    }
+    if (!args || typeof args !== "object" || Array.isArray(args)) {
+      throw new Error("callMcpTool arguments must be an object when provided");
+    }
+    return args;
+  }
+  return {};
+}
+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; 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({
+          minLength: 1,
+          description: "Exact MCP tool_name from searchMcpTools."
+        }),
+        arguments: Type4.Optional(
+          Type4.Record(Type4.String(), Type4.Unknown(), {
+            description: 'Arguments matching the disclosed MCP tool schema, for example { "query": "..." } when searchMcpTools shows query is required.'
+          })
+        )
+      },
+      { additionalProperties: false }
+    ),
+    execute: async (input) => {
+      const { tool_name } = input;
+      const mcpTool = mcpToolManager.getResolvedActiveTools(getActiveSkills()).find((candidate) => candidate.name === tool_name);
+      if (!mcpTool) {
+        throw new Error(`MCP tool is not active for this turn: ${tool_name}`);
+      }
+      return await mcpTool.execute(
+        resolveMcpArguments(input)
+      );
+    }
+  });
+}
+
+// src/chat/tools/skill/load-skill.ts
+import { Type as Type5 } from "@sinclair/typebox";
 function toLoadedSkill(result, availableSkills) {
   if (result.ok !== true || typeof result.skill_name !== "string" || typeof result.description !== "string" || typeof result.skill_dir !== "string" || typeof result.instructions !== "string") {
     return null;
@@ -4797,7 +4949,6 @@ function toLoadedSkill(result, availableSkills) {
     skillPath: metadata?.skillPath ?? result.skill_dir,
     ...metadata?.pluginProvider ? { pluginProvider: metadata.pluginProvider } : {},
     ...metadata?.allowedTools ? { allowedTools: metadata.allowedTools } : {},
-    ...metadata?.usesConfig ? { usesConfig: metadata.usesConfig } : {},
     body: result.instructions
   };
 }
@@ -4824,15 +4975,17 @@ 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 are available for this turn. The result includes `available_tools` when the skill exposes MCP tools for this turn. Use when a request clearly matches a known skill. Do not use when no skill is relevant.",
-    inputSchema: Type4.Object({
-      skill_name: Type4.String({
+    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,
         description: "Skill name to load, without the leading slash."
       })
@@ -4851,53 +5004,87 @@ function createLoadSkillTool(availableSkills, options) {
   });
 }
 
-// src/chat/tools/sandbox/read-file.ts
-import { Type as Type5 } from "@sinclair/typebox";
-function createReadFileTool() {
-  return tool({
-    description: "Read a file from the sandbox workspace. Use when you need exact file contents to verify facts or make edits safely. Do not use for broad discovery when search tools are better.",
-    inputSchema: Type5.Object(
-      {
-        path: Type5.String({
-          minLength: 1,
-          description: "Path to the file in the sandbox workspace."
-        })
-      },
-      { additionalProperties: false }
-    ),
-    execute: async () => {
-      throw new Error(
-        "readFile can only run when sandbox execution is enabled."
-      );
-    }
-  });
-}
-
-// src/chat/tools/runtime/report-progress.ts
+// src/chat/tools/skill/search-mcp-tools.ts
 import { Type as Type6 } from "@sinclair/typebox";
-function createReportProgressTool() {
-  return tool({
-    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: Type6.Object({
-      message: Type6.String({
-        minLength: 1,
-        description: "Short user-facing progress message."
-      })
-    })
-  });
-}
-
-// src/chat/tools/skill/search-tools.ts
-import { Type as Type7 } from "@sinclair/typebox";
 
 // src/chat/tools/skill/mcp-tool-summary.ts
-function summarizeInputSchema(schema) {
-  const properties = schema.properties && typeof schema.properties === "object" ? schema.properties : {};
-  const required = Array.isArray(schema.required) ? new Set(
+function getSchemaProperties(schema) {
+  return schema.properties && typeof schema.properties === "object" ? schema.properties : {};
+}
+function getRequiredFields(schema) {
+  return Array.isArray(schema.required) ? new Set(
     schema.required.filter(
       (value) => typeof value === "string"
     )
   ) : /* @__PURE__ */ new Set();
+}
+function formatSchemaType(schema) {
+  if (!schema || typeof schema !== "object") {
+    return "unknown";
+  }
+  const typed = schema;
+  const type = typed.type;
+  if (typeof type === "string") {
+    if (type === "array") {
+      return `${formatSchemaType(typed.items)}[]`;
+    }
+    return type;
+  }
+  if (Array.isArray(type)) {
+    return type.filter((value) => typeof value === "string").join(" | ");
+  }
+  if (Array.isArray(typed.enum) && typed.enum.length > 0) {
+    return typed.enum.map((value) => JSON.stringify(value)).join(" | ");
+  }
+  return "unknown";
+}
+function formatArgumentPlaceholder(name, schema) {
+  const type = formatSchemaType(schema);
+  if (type === "string") {
+    return `<${name}>`;
+  }
+  if (type === "number" || type === "integer") {
+    return "<number>";
+  }
+  if (type === "boolean") {
+    return "<boolean>";
+  }
+  if (type.endsWith("[]")) {
+    return "<array>";
+  }
+  if (type === "object") {
+    return "<object>";
+  }
+  return `<${type}>`;
+}
+function formatMcpToolSignature(toolName, schema) {
+  const properties = getSchemaProperties(schema);
+  const required = getRequiredFields(schema);
+  const fields = Object.entries(properties).map(([name, propertySchema]) => {
+    const marker = required.has(name) ? "" : "?";
+    return `${name}${marker}: ${formatSchemaType(propertySchema)}`;
+  });
+  if (fields.length === 0) {
+    return `${toolName}()`;
+  }
+  return `${toolName}({ ${fields.join(", ")} })`;
+}
+function formatMcpToolCallExample(toolName, schema) {
+  return {
+    tool_name: toolName,
+    arguments: Object.fromEntries(
+      Object.entries(getSchemaProperties(schema)).map(
+        ([name, propertySchema]) => [
+          name,
+          formatArgumentPlaceholder(name, propertySchema)
+        ]
+      )
+    )
+  };
+}
+function summarizeInputSchema(schema) {
+  const properties = getSchemaProperties(schema);
+  const required = getRequiredFields(schema);
   const propertyNames = Object.keys(properties);
   if (propertyNames.length === 0) {
     return "No arguments.";
@@ -4907,59 +5094,190 @@ function summarizeInputSchema(schema) {
 function toExposedToolSummary(toolDef) {
   return {
     tool_name: toolDef.name,
+    mcp_tool_name: toolDef.rawName,
     provider: toolDef.provider,
+    ...toolDef.title ? { title: toolDef.title } : {},
     description: toolDef.description,
+    signature: formatMcpToolSignature(toolDef.name, toolDef.parameters),
+    call: formatMcpToolCallExample(toolDef.name, toolDef.parameters),
     input_schema: toolDef.parameters,
-    input_schema_summary: summarizeInputSchema(toolDef.parameters)
+    input_schema_summary: summarizeInputSchema(toolDef.parameters),
+    ...toolDef.outputSchema ? { output_schema: toolDef.outputSchema } : {},
+    ...toolDef.annotations ? { annotations: toolDef.annotations } : {}
   };
 }
-
-// src/chat/tools/skill/search-tools.ts
-var DEFAULT_LIMIT = 5;
-var MAX_LIMIT = 20;
-function createSearchToolsTool(mcpToolManager, getActiveSkills) {
+function toActiveMcpCatalogSummaries(toolDefs) {
+  const countsByProvider = /* @__PURE__ */ new Map();
+  for (const toolDef of toolDefs) {
+    countsByProvider.set(
+      toolDef.provider,
+      (countsByProvider.get(toolDef.provider) ?? 0) + 1
+    );
+  }
+  return [...countsByProvider.entries()].map(([provider, availableToolCount]) => ({
+    provider,
+    available_tool_count: availableToolCount
+  })).sort((left, right) => left.provider.localeCompare(right.provider));
+}
+
+// src/chat/tools/skill/search-mcp-tools.ts
+var DEFAULT_MAX_RESULTS = 5;
+var MAX_RESULTS = 20;
+function normalize(value) {
+  return value.toLowerCase().replace(/[^a-z0-9_]+/g, " ").trim();
+}
+function searchableToolText(toolDef) {
+  return normalize(
+    [
+      toolDef.name,
+      toolDef.rawName,
+      toolDef.title,
+      toolDef.provider,
+      toolDef.description,
+      JSON.stringify(toolDef.parameters),
+      JSON.stringify(toolDef.outputSchema),
+      JSON.stringify(toolDef.annotations)
+    ].filter(Boolean).join(" ")
+  );
+}
+function scoreTool(toolDef, query) {
+  const normalizedQuery = normalize(query);
+  if (!normalizedQuery) {
+    return 0;
+  }
+  const normalizedName = normalize(toolDef.name);
+  const normalizedRawName = normalize(toolDef.rawName);
+  const text = searchableToolText(toolDef);
+  let score = 0;
+  if (normalizedName === normalizedQuery || normalizedRawName === normalizedQuery) {
+    score += 100;
+  }
+  if (normalizedName.includes(normalizedQuery)) {
+    score += 50;
+  }
+  if (normalizedRawName.includes(normalizedQuery)) {
+    score += 45;
+  }
+  if (text.includes(normalizedQuery)) {
+    score += 25;
+  }
+  for (const term of normalizedQuery.split(/\s+/).filter(Boolean)) {
+    if (normalizedName.includes(term)) {
+      score += 12;
+    }
+    if (normalizedRawName.includes(term)) {
+      score += 10;
+    }
+    if (text.includes(term)) {
+      score += 4;
+    }
+  }
+  return score;
+}
+function searchMcpCatalog(tools, query) {
+  if (!normalize(query)) {
+    return [...tools].sort(
+      (left, right) => left.name.localeCompare(right.name)
+    );
+  }
+  return tools.map(
+    (toolDef) => ({
+      tool: toolDef,
+      score: scoreTool(toolDef, query)
+    })
+  ).filter((ranked) => ranked.score > 0).sort((left, right) => {
+    if (right.score !== left.score) {
+      return right.score - left.score;
+    }
+    return left.tool.name.localeCompare(right.tool.name);
+  }).map((ranked) => ranked.tool);
+}
+function createSearchMcpToolsTool(mcpToolManager, getActiveSkills) {
   return tool({
-    description: "Search active MCP tools exposed by the currently loaded skills. Use when you need to rediscover or filter active tools.",
-    inputSchema: Type7.Object(
+    description: "List or search active MCP tools and return full descriptors, including input/output schemas and annotations. Use after loadSkill when choosing a provider tool or when callMcpTool arguments are unclear.",
+    inputSchema: Type6.Object(
       {
-        query: Type7.String({
-          minLength: 1,
-          description: "Search query for matching MCP tool names or descriptions."
-        }),
-        provider: Type7.Optional(
-          Type7.String({
+        query: Type6.Optional(
+          Type6.String({
             minLength: 1,
-            description: "Optional MCP provider filter, for example notion or sentry."
+            description: "Optional search terms describing the MCP tool or arguments needed."
           })
         ),
-        limit: Type7.Optional(
-          Type7.Integer({
+        provider: Type6.Optional(
+          Type6.String({
+            minLength: 1,
+            description: "Optional provider name to list or search within."
+          })
+        ),
+        max_results: Type6.Optional(
+          Type6.Integer({
             minimum: 1,
-            maximum: MAX_LIMIT,
-            description: "Maximum number of matching tools to return."
+            maximum: MAX_RESULTS,
+            description: "Maximum matching tool descriptors to return."
           })
         )
       },
       { additionalProperties: false }
     ),
-    execute: async ({ query, provider, limit }) => {
-      const results = mcpToolManager.searchTools(getActiveSkills(), query, {
-        ...provider ? { provider } : {},
-        limit: limit ?? DEFAULT_LIMIT
-      }).map(toExposedToolSummary);
+    execute: async ({ query, provider, max_results }) => {
+      const catalog = mcpToolManager.getActiveToolCatalog(
+        getActiveSkills(),
+        provider ? { provider } : {}
+      );
+      const maxResults = max_results ?? DEFAULT_MAX_RESULTS;
+      const matches = searchMcpCatalog(catalog, query ?? "").slice(
+        0,
+        maxResults
+      );
       return {
-        ok: true,
-        query,
-        ...provider ? { provider } : {},
-        result_count: results.length,
-        results
+        query: query ?? null,
+        provider: provider ?? null,
+        total_active_tools: catalog.length,
+        returned_tools: matches.length,
+        tools: matches.map(toExposedToolSummary)
       };
     }
   });
 }
 
-// src/chat/tools/slack/channel-list-messages.ts
+// src/chat/tools/sandbox/read-file.ts
+import { Type as Type7 } from "@sinclair/typebox";
+function createReadFileTool() {
+  return tool({
+    description: "Read a file from the sandbox workspace. Use when you need exact file contents to verify facts or make edits safely. Do not use for broad discovery when search tools are better.",
+    inputSchema: Type7.Object(
+      {
+        path: Type7.String({
+          minLength: 1,
+          description: "Path to the file in the sandbox workspace."
+        })
+      },
+      { additionalProperties: false }
+    ),
+    execute: async () => {
+      throw new Error(
+        "readFile can only run when sandbox execution is enabled."
+      );
+    }
+  });
+}
+
+// src/chat/tools/runtime/report-progress.ts
 import { Type as Type8 } from "@sinclair/typebox";
+function createReportProgressTool() {
+  return tool({
+    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: Type8.Object({
+      message: Type8.String({
+        minLength: 1,
+        description: "Short user-facing progress message."
+      })
+    })
+  });
+}
+
+// src/chat/tools/slack/channel-list-messages.ts
+import { Type as Type9 } from "@sinclair/typebox";
 
 // src/chat/slack/channel.ts
 async function listChannelMessages(input) {
@@ -5048,39 +5366,39 @@ async function listThreadReplies(input) {
 function createSlackChannelListMessagesTool(context) {
   return tool({
     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.",
-    inputSchema: Type8.Object({
-      limit: Type8.Optional(
-        Type8.Integer({
+    inputSchema: Type9.Object({
+      limit: Type9.Optional(
+        Type9.Integer({
           minimum: 1,
           maximum: 1e3,
           description: "Maximum number of messages to return across pages."
         })
       ),
-      cursor: Type8.Optional(
-        Type8.String({
+      cursor: Type9.Optional(
+        Type9.String({
           minLength: 1,
           description: "Optional cursor to continue from a prior call."
         })
       ),
-      oldest: Type8.Optional(
-        Type8.String({
+      oldest: Type9.Optional(
+        Type9.String({
           minLength: 1,
           description: "Optional oldest message timestamp (Slack ts) for range filtering."
         })
       ),
-      latest: Type8.Optional(
-        Type8.String({
+      latest: Type9.Optional(
+        Type9.String({
           minLength: 1,
           description: "Optional latest message timestamp (Slack ts) for range filtering."
         })
       ),
-      inclusive: Type8.Optional(
-        Type8.Boolean({
+      inclusive: Type9.Optional(
+        Type9.Boolean({
           description: "Whether oldest/latest bounds should be inclusive."
         })
       ),
-      max_pages: Type8.Optional(
-        Type8.Integer({
+      max_pages: Type9.Optional(
+        Type9.Integer({
           minimum: 1,
           maximum: 10,
           description: "Maximum number of API pages to traverse in a single call."
@@ -5134,7 +5452,7 @@ function createSlackChannelListMessagesTool(context) {
 }
 
 // src/chat/tools/slack/channel-post-message.ts
-import { Type as Type9 } from "@sinclair/typebox";
+import { Type as Type10 } from "@sinclair/typebox";
 
 // src/chat/tools/idempotency.ts
 function stableSerialize(value) {
@@ -5156,8 +5474,8 @@ function createOperationKey(toolName, input) {
 function createSlackChannelPostMessageTool(context, state) {
   return tool({
     description: "Post a message in the active Slack channel context (outside the thread). Use this only when the user explicitly asks to post/send/share/say something in the current channel. Do not use it for normal thread replies, speculative broadcasts, or requests targeting another named channel; explain that limitation instead. Do not claim a channel message was posted unless this tool succeeds in this turn.",
-    inputSchema: Type9.Object({
-      text: Type9.String({
+    inputSchema: Type10.Object({
+      text: Type10.String({
         minLength: 1,
         maxLength: 4e4,
         description: "Slack mrkdwn text to post."
@@ -5200,12 +5518,12 @@ function createSlackChannelPostMessageTool(context, state) {
 }
 
 // src/chat/tools/slack/message-add-reaction.ts
-import { Type as Type10 } from "@sinclair/typebox";
+import { Type as Type11 } from "@sinclair/typebox";
 function createSlackMessageAddReactionTool(context, state) {
   return tool({
     description: "Add an emoji reaction to the current inbound Slack message. Use sparingly for lightweight acknowledgements. 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: Type10.Object({
-      emoji: Type10.String({
+    inputSchema: Type11.Object({
+      emoji: Type11.String({
         minLength: 1,
         maxLength: 64,
         description: "Slack emoji alias name to react with (for example `thumbsup`, `white_check_mark`, or `thumbsup::skin-tone-6`). Optional surrounding colons are allowed."
@@ -5263,7 +5581,7 @@ function createSlackMessageAddReactionTool(context, state) {
 }
 
 // src/chat/tools/slack/canvas-tools.ts
-import { Type as Type11 } from "@sinclair/typebox";
+import { Type as Type12 } from "@sinclair/typebox";
 
 // src/chat/tools/slack/canvases.ts
 function normalizeCanvasMarkdown(markdown) {
@@ -5478,14 +5796,14 @@ 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.",
-    inputSchema: Type11.Object({
-      title: Type11.String({
+    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,
         maxLength: 160,
         description: "Canvas title."
       }),
-      markdown: Type11.String({
+      markdown: Type12.String({
         minLength: 1,
         description: "Canvas markdown body content."
       })
@@ -5551,29 +5869,29 @@ function createSlackCanvasCreateTool(context, state) {
 function createSlackCanvasUpdateTool(state, _context) {
   return tool({
     description: "Update the active Slack canvas tracked in artifact context. Use when continuing or correcting a document already tracked in this thread. Do not use to create a brand-new long-form artifact.",
-    inputSchema: Type11.Object({
-      markdown: Type11.String({
+    inputSchema: Type12.Object({
+      markdown: Type12.String({
         minLength: 1,
         description: "Markdown content to insert or use as replacement text."
       }),
-      operation: Type11.Optional(
-        Type11.Union(
+      operation: Type12.Optional(
+        Type12.Union(
           [
-            Type11.Literal("insert_at_end"),
-            Type11.Literal("insert_at_start"),
-            Type11.Literal("replace")
+            Type12.Literal("insert_at_end"),
+            Type12.Literal("insert_at_start"),
+            Type12.Literal("replace")
           ],
           { description: "Canvas update mode." }
         )
       ),
-      section_id: Type11.Optional(
-        Type11.String({
+      section_id: Type12.Optional(
+        Type12.String({
           minLength: 1,
           description: "Optional section ID required for targeted replace operations."
         })
       ),
-      section_contains_text: Type11.Optional(
-        Type11.String({
+      section_contains_text: Type12.Optional(
+        Type12.String({
           minLength: 1,
           description: "Optional helper text used to find the target section when section_id is not provided."
         })
@@ -5639,8 +5957,8 @@ function createSlackCanvasUpdateTool(state, _context) {
 function createSlackCanvasReadTool() {
   return tool({
     description: "Read a Slack canvas the bot has access to (including canvases the bot created) by canvas ID or Slack canvas/docs URL. Use when the user shares a Slack canvas link (https://*.slack.com/docs/... or /canvas/...) or references a canvas ID and you need its contents. Do not use for generic web pages \u2014 use webFetch for those.",
-    inputSchema: Type11.Object({
-      canvas: Type11.String({
+    inputSchema: Type12.Object({
+      canvas: Type12.String({
         minLength: 1,
         description: "Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL (e.g. `https://team.slack.com/docs/T.../F...`)."
       })
@@ -5690,7 +6008,7 @@ function createSlackCanvasReadTool() {
 }
 
 // src/chat/tools/slack/list-tools.ts
-import { Type as Type12 } from "@sinclair/typebox";
+import { Type as Type13 } from "@sinclair/typebox";
 
 // src/chat/tools/slack/lists.ts
 function normalizeKey(value) {
@@ -5864,8 +6182,8 @@ async function updateListItem(input) {
 function createSlackListCreateTool(state) {
   return tool({
     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: Type12.Object({
-      name: Type12.String({
+    inputSchema: Type13.Object({
+      name: Type13.String({
         minLength: 1,
         maxLength: 160,
         description: "Name for the new Slack list."
@@ -5900,20 +6218,20 @@ function createSlackListCreateTool(state) {
 function createSlackListAddItemsTool(state) {
   return tool({
     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: Type12.Object({
-      items: Type12.Array(Type12.String({ minLength: 1 }), {
+    inputSchema: Type13.Object({
+      items: Type13.Array(Type13.String({ minLength: 1 }), {
         minItems: 1,
         maxItems: 25,
         description: "List item titles to create."
       }),
-      assignee_user_id: Type12.Optional(
-        Type12.String({
+      assignee_user_id: Type13.Optional(
+        Type13.String({
           minLength: 1,
           description: "Optional Slack user ID assigned to all created items."
         })
       ),
-      due_date: Type12.Optional(
-        Type12.String({
+      due_date: Type13.Optional(
+        Type13.String({
           pattern: "^\\d{4}-\\d{2}-\\d{2}$",
           description: "Optional due date in YYYY-MM-DD format."
         })
@@ -5962,9 +6280,9 @@ function createSlackListAddItemsTool(state) {
 function createSlackListGetItemsTool(state) {
   return tool({
     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.",
-    inputSchema: Type12.Object({
-      limit: Type12.Optional(
-        Type12.Integer({
+    inputSchema: Type13.Object({
+      limit: Type13.Optional(
+        Type13.Integer({
           minimum: 1,
           maximum: 200,
           description: "Maximum number of list items to return."
@@ -5989,19 +6307,19 @@ function createSlackListGetItemsTool(state) {
 function createSlackListUpdateItemTool(state) {
   return tool({
     description: "Update an item in the active Slack list tracked in artifact context (title/completion). Use when the user asks to mark progress or rename a tracked task. Do not use to add new tasks.",
-    inputSchema: Type12.Object(
+    inputSchema: Type13.Object(
       {
-        item_id: Type12.String({
+        item_id: Type13.String({
           minLength: 1,
           description: "ID of the Slack list item to update."
         }),
-        completed: Type12.Optional(
-          Type12.Boolean({
+        completed: Type13.Optional(
+          Type13.Boolean({
             description: "Optional completion status update."
           })
         ),
-        title: Type12.Optional(
-          Type12.String({
+        title: Type13.Optional(
+          Type13.String({
             minLength: 1,
             description: "Optional new item title."
           })
@@ -6051,11 +6369,11 @@ function createSlackListUpdateItemTool(state) {
 }
 
 // src/chat/tools/system-time.ts
-import { Type as Type13 } from "@sinclair/typebox";
+import { Type as Type14 } from "@sinclair/typebox";
 function createSystemTimeTool() {
   return tool({
     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.",
-    inputSchema: Type13.Object({}),
+    inputSchema: Type14.Object({}),
     execute: async () => {
       const now = /* @__PURE__ */ new Date();
       return {
@@ -6070,7 +6388,7 @@ function createSystemTimeTool() {
 }
 
 // src/chat/tools/web/fetch-tool.ts
-import { Type as Type14 } from "@sinclair/typebox";
+import { Type as Type15 } from "@sinclair/typebox";
 
 // src/chat/tools/web/constants.ts
 var USER_AGENT = "junior-bot/0.1";
@@ -6219,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
-            })
-          );
         });
       }
     );
@@ -6328,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
@@ -6418,13 +6733,13 @@ function extractHttpStatusFromMessage(message) {
 function createWebFetchTool(hooks) {
   return tool({
     description: "Fetch and extract readable content from a specific URL. Use when you need details from a known page or document. Do not use for discovery when search is the first step.",
-    inputSchema: Type14.Object({
-      url: Type14.String({
+    inputSchema: Type15.Object({
+      url: Type15.String({
         minLength: 1,
         description: "HTTP(S) URL to fetch."
       }),
-      max_chars: Type14.Optional(
-        Type14.Integer({
+      max_chars: Type15.Optional(
+        Type15.Integer({
           minimum: 500,
           maximum: MAX_FETCH_CHARS,
           description: "Optional maximum number of extracted characters to return."
@@ -6484,9 +6799,9 @@ function createWebFetchTool(hooks) {
 // src/chat/tools/web/search.ts
 import { generateText } from "ai";
 import { createGatewayProvider } from "@ai-sdk/gateway";
-import { Type as Type15 } from "@sinclair/typebox";
+import { Type as Type16 } from "@sinclair/typebox";
 var SEARCH_TIMEOUT_MS = 6e4;
-var MAX_RESULTS = 5;
+var MAX_RESULTS2 = 5;
 var DEFAULT_SEARCH_MODEL = "xai/grok-4-fast-reasoning";
 var SEARCH_TOOL_NAME = "parallelSearch";
 function asString(value) {
@@ -6527,16 +6842,16 @@ function isAuthFailure(message) {
 function createWebSearchTool() {
   return tool({
     description: "Search public web sources and return top snippets/URLs. Use when you need discovery or source candidates. Do not use when the user already provided a specific URL to inspect.",
-    inputSchema: Type15.Object({
-      query: Type15.String({
+    inputSchema: Type16.Object({
+      query: Type16.String({
         minLength: 1,
         maxLength: 500,
         description: "Search query."
       }),
-      max_results: Type15.Optional(
-        Type15.Integer({
+      max_results: Type16.Optional(
+        Type16.Integer({
           minimum: 1,
-          maximum: MAX_RESULTS,
+          maximum: MAX_RESULTS2,
           description: "Max results to return."
         })
       )
@@ -6600,17 +6915,17 @@ function createWebSearchTool() {
 }
 
 // src/chat/tools/sandbox/write-file.ts
-import { Type as Type16 } from "@sinclair/typebox";
+import { Type as Type17 } from "@sinclair/typebox";
 function createWriteFileTool() {
   return tool({
     description: "Write UTF-8 content to a file in the sandbox workspace. Use for intentional file creation or replacement after validation. Do not use for exploratory analysis-only turns.",
-    inputSchema: Type16.Object(
+    inputSchema: Type17.Object(
       {
-        path: Type16.String({
+        path: Type17.String({
           minLength: 1,
           description: "Path to write in the sandbox workspace."
         }),
-        content: Type16.String({
+        content: Type17.String({
           description: "UTF-8 file content to write."
         })
       },
@@ -6685,7 +7000,11 @@ function createTools(availableSkills, hooks = {}, context) {
     slackListUpdateItem: createSlackListUpdateItemTool(state)
   };
   if (context.mcpToolManager && context.getActiveSkills) {
-    tools.searchTools = createSearchToolsTool(
+    tools.searchMcpTools = createSearchMcpToolsTool(
+      context.mcpToolManager,
+      context.getActiveSkills
+    );
+    tools.callMcpTool = createCallMcpToolTool(
       context.mcpToolManager,
       context.getActiveSkills
     );
@@ -7264,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 {
@@ -7273,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 {
@@ -8375,8 +8704,10 @@ function getToolErrorAttributes(error) {
   };
 }
 function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, traceContext) {
+  const errorType = getMcpAwareErrorType(error, "tool_execution_error");
+  const errorMessage = getMcpAwareErrorMessage(error);
   setSpanAttributes({
-    "error.type": error instanceof Error ? error.name : "tool_execution_error"
+    "error.type": errorType
   });
   if (shouldTrace) {
     logWarn(
@@ -8387,8 +8718,8 @@ 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": error instanceof Error ? error.name : "tool_execution_error",
-        "error.message": error instanceof Error ? error.message : String(error)
+        "error.type": errorType,
+        "error.message": errorMessage
       },
       "Agent tool call failed"
     );
@@ -8422,7 +8753,6 @@ function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor
     execute: async (toolCallId, params) => {
       const normalizedToolCallId = typeof toolCallId === "string" && toolCallId.length > 0 ? toolCallId : void 0;
       const toolArgumentsAttribute = serializeGenAiAttribute(params);
-      onToolCall?.(toolName);
       const traceToolContext = {
         ...spanContext,
         conversationId: spanContext.conversationId,
@@ -8441,6 +8771,7 @@ function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor
         spanContext,
         async () => {
           const parsed = params;
+          onToolCall?.(toolName, parsed);
           try {
             if (typeof toolDef.execute !== "function") {
               const resultDetails = { ok: true };
@@ -8710,24 +9041,11 @@ function upsertActiveSkill(activeSkills, next) {
     existing.description = next.description;
     existing.skillPath = next.skillPath;
     existing.allowedTools = next.allowedTools;
-    existing.usesConfig = next.usesConfig;
     existing.pluginProvider = next.pluginProvider;
     return;
   }
   activeSkills.push(next);
 }
-function collectRelevantConfigurationKeys(activeSkills, explicitSkill) {
-  const keys = /* @__PURE__ */ new Set();
-  for (const skill of [
-    ...activeSkills,
-    ...explicitSkill ? [explicitSkill] : []
-  ]) {
-    for (const key of skill.usesConfig ?? []) {
-      keys.add(key);
-    }
-  }
-  return [...keys].sort((a, b) => a.localeCompare(b));
-}
 function trimTrailingAssistantMessages(messages) {
   let end = messages.length;
   while (end > 0 && getPiMessageRole(messages[end - 1]) === "assistant") {
@@ -8739,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, "");
 }
@@ -8755,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";
@@ -8815,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,
@@ -8844,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,
@@ -8876,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 ? {
@@ -8940,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) {
@@ -8963,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.",
     "",
@@ -9042,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({
@@ -9069,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 {
@@ -9710,20 +10079,6 @@ function buildUserTurnInput(args) {
   }
   return { routerBlocks, userContentParts };
 }
-function mcpToolsToDefinitions(mcpTools) {
-  const defs = {};
-  for (const tool2 of mcpTools) {
-    defs[tool2.name] = {
-      description: tool2.description,
-      // Raw JSON Schema from MCP servers — not a TypeBox TSchema, but
-      // pi-agent-core validates with AJV and the Anthropic provider reads
-      // .properties/.required, so raw JSON Schema works at runtime.
-      inputSchema: tool2.parameters,
-      execute: async (args) => tool2.execute(args)
-    };
-  }
-  return defs;
-}
 async function generateAssistantReply(messageText, context = {}) {
   const replyStartedAtMs = Date.now();
   let timeoutResumeConversationId;
@@ -9818,6 +10173,7 @@ async function generateAssistantReply(messageText, context = {}) {
     timeoutResumeSliceId = currentSliceId;
     const persistedConfigurationValues = context.channelConfiguration ? await context.channelConfiguration.resolveValues() : {};
     configurationValues = {
+      ...getConfigDefaults(),
       ...context.configuration ?? {},
       ...persistedConfigurationValues
     };
@@ -10020,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,
       {
@@ -10057,19 +10415,24 @@ async function generateAssistantReply(messageText, context = {}) {
           if (!effective.pluginProvider) {
             return void 0;
           }
-          syncMcpAgentTools();
-          return {
-            available_tools: turnMcpToolManager.getActiveToolCatalog(activeSkills, {
+          if (!turnMcpToolManager.getActiveProviders().includes(effective.pluginProvider)) {
+            return void 0;
+          }
+          const availableToolCount = turnMcpToolManager.getActiveToolCatalog(
+            activeSkills,
+            {
               provider: effective.pluginProvider
-            }).map(toExposedToolSummary)
+            }
+          ).length;
+          return {
+            mcp_provider: effective.pluginProvider,
+            available_tool_count: availableToolCount
           };
         }
       },
       {
-        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,
@@ -10091,22 +10454,27 @@ async function generateAssistantReply(messageText, context = {}) {
       await enableSkillCredentials(skill, `skill:${skill.name}:turn:resume`);
     }
     syncResumeState();
-    const activeToolSummaries = turnMcpToolManager.getActiveToolCatalog(activeSkills).map(toExposedToolSummary);
+    const activeMcpCatalogs = toActiveMcpCatalogSummaries(
+      turnMcpToolManager.getActiveToolCatalog(activeSkills)
+    );
     baseInstructions = buildSystemPrompt({
       availableSkills,
       activeSkills,
-      activeTools: activeToolSummaries,
+      activeMcpCatalogs,
+      runtime: {
+        channelId: toolChannelId,
+        fastModelId: botConfig.fastModelId,
+        modelId: botConfig.modelId,
+        slackCapabilities: channelCapabilities,
+        thinkingLevel: thinkingSelection.thinkingLevel
+      },
       invocation: skillInvocation,
       assistant: context.assistant,
       requester: context.requester,
       artifactState: context.artifactState,
       configuration: configurationValues,
-      relevantConfigurationKeys: collectRelevantConfigurationKeys(
-        activeSkills,
-        invokedSkill
-      ),
-      runtimeMetadata: getRuntimeMetadata(),
-      threadParticipants: context.threadParticipants
+      threadParticipants: context.threadParticipants,
+      turnState: resumedFromCheckpoint ? "resumed" : "fresh"
     });
     const inputMessagesAttribute = serializeGenAiAttribute([
       {
@@ -10118,10 +10486,23 @@ async function generateAssistantReply(messageText, context = {}) {
         content: userContentParts.map((part) => toObservablePromptPart(part))
       }
     ]);
-    const onToolCall = (toolName) => {
+    const onToolCall = (toolName, params) => {
       toolCalls.push(toolName);
+      try {
+        context.onToolInvocation?.({ toolName, params });
+      } catch (error) {
+        logWarn(
+          "tool_invocation_observer_failed",
+          spanContext,
+          {
+            "gen_ai.tool.name": toolName,
+            "error.message": error instanceof Error ? error.message : String(error)
+          },
+          "Tool invocation observer failed"
+        );
+      }
     };
-    const baseAgentTools = createAgentTools(
+    const agentTools = createAgentTools(
       tools,
       skillSandbox,
       spanContext,
@@ -10131,24 +10512,6 @@ async function generateAssistantReply(messageText, context = {}) {
       pluginAuth,
       onToolCall
     );
-    const agentTools = [...baseAgentTools];
-    const syncMcpAgentTools = () => {
-      const mcpTools = turnMcpToolManager.getResolvedActiveTools(activeSkills);
-      const mcpDefs = mcpToolsToDefinitions(mcpTools);
-      const mcpAgentTools = createAgentTools(
-        mcpDefs,
-        skillSandbox,
-        spanContext,
-        context.onStatus,
-        sandboxExecutor,
-        capabilityRuntime,
-        pluginAuth,
-        onToolCall
-      );
-      agentTools.length = 0;
-      agentTools.push(...baseAgentTools, ...mcpAgentTools);
-    };
-    syncMcpAgentTools();
     agent = new Agent({
       getApiKey: () => getPiGatewayApiKeyOverride(),
       initialState: {
@@ -15686,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) => {