@sentry/junior 0.48.0 → 0.50.0

package/dist/app.js

@@ -3,7 +3,7 @@ import {
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-ZUUJTQ2H.js";
+} from "./chunk-AYM42AN3.js";
 import {
   GEN_AI_PROVIDER_NAME,
   MISSING_GATEWAY_CREDENTIALS_ERROR,
@@ -31,7 +31,7 @@ import {
   runNonInteractiveCommand,
   sandboxSkillDir,
   sandboxSkillFile
-} from "./chunk-ELM6HJ6S.js";
+} from "./chunk-AQ4RO2WA.js";
 import {
   CredentialUnavailableError,
   buildOAuthTokenRequest,
@@ -61,6 +61,7 @@ import {
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv,
   serializeGenAiAttribute,
+  setPluginConfig,
   setSpanAttributes,
   setSpanStatus,
   setTags,
@@ -68,7 +69,7 @@ import {
   toOptionalString,
   withContext,
   withSpan
-} from "./chunk-BCG3I2T2.js";
+} from "./chunk-UKR24HLJ.js";
 import {
   sentry_exports
 } from "./chunk-Z3YD6NHK.js";
@@ -2448,6 +2449,12 @@ import { Agent as Agent2 } from "@mariozechner/pi-agent-core";
 import fs from "fs";
 import path2 from "path";
 
+// src/chat/interruption-marker.ts
+var INTERRUPTED_MARKER = "\n\n[Response interrupted before completion]";
+function getInterruptionMarker() {
+  return INTERRUPTED_MARKER;
+}
+
 // src/chat/slack/status-format.ts
 var SLACK_STATUS_MAX_LENGTH = 50;
 function truncateStatusText(text) {
@@ -2511,7 +2518,6 @@ function normalizeSlackStatusText(text) {
 var MAX_INLINE_CHARS = 2200;
 var MAX_INLINE_LINES = 45;
 var CONTINUED_MARKER = "\n\n[Continued below]";
-var INTERRUPTED_MARKER = "\n\n[Response interrupted before completion]";
 function countSlackLines(text) {
   if (!text) {
     return 0;
@@ -2678,10 +2684,10 @@ function splitSlackReplyText(text, options) {
   const continuationBudget = reserveInlineBudgetForSuffix(CONTINUED_MARKER);
   let remaining = normalized;
   while (remaining) {
-    const fitsFinalChunk = options?.interrupted ? fitsInlineBudget(appendSlackSuffix(remaining, INTERRUPTED_MARKER)) : fitsInlineBudget(remaining);
+    const fitsFinalChunk = options?.interrupted ? fitsInlineBudget(appendSlackSuffix(remaining, getInterruptionMarker())) : fitsInlineBudget(remaining);
     if (fitsFinalChunk) {
       chunks.push(
-        options?.interrupted ? appendSlackSuffix(remaining, INTERRUPTED_MARKER) : remaining
+        options?.interrupted ? appendSlackSuffix(remaining, getInterruptionMarker()) : remaining
       );
       break;
     }
@@ -2831,26 +2837,50 @@ function renderTag(tag, lines) {
 function renderTagBlock(tag, content) {
   return [`<${tag}>`, content, `</${tag}>`].join("\n");
 }
-function formatAvailableSkillsForPrompt(skills) {
-  if (skills.length === 0) {
-    return "<available-skills>\n</available-skills>";
-  }
-  const lines = ["<available-skills>"];
-  for (const skill of skills) {
-    const skillLocation = `${workspaceSkillDir(skill.name)}/SKILL.md`;
-    lines.push("  <skill>");
-    lines.push(`    <name>${escapeXml(skill.name)}</name>`);
-    lines.push(
-      `    <description>${escapeXml(skill.description)}</description>`
-    );
-    lines.push(`    <location>${escapeXml(skillLocation)}</location>`);
-    if (skill.pluginProvider) {
-      lines.push(`    <provider>${escapeXml(skill.pluginProvider)}</provider>`);
+function formatSkillEntry(skill) {
+  const skillLocation = `${workspaceSkillDir(skill.name)}/SKILL.md`;
+  const lines = [];
+  lines.push("  <skill>");
+  lines.push(`    <name>${escapeXml(skill.name)}</name>`);
+  lines.push(`    <description>${escapeXml(skill.description)}</description>`);
+  lines.push(`    <location>${escapeXml(skillLocation)}</location>`);
+  if (skill.pluginProvider) {
+    lines.push(`    <provider>${escapeXml(skill.pluginProvider)}</provider>`);
+  }
+  lines.push("  </skill>");
+  return lines;
+}
+function formatAvailableSkillsForPrompt(skills, invocation) {
+  const autoSelectable = skills.filter(
+    (s) => s.disableModelInvocation !== true
+  );
+  const invokedExplicitOnly = invocation ? skills.filter(
+    (s) => s.disableModelInvocation === true && s.name === invocation.skillName
+  ) : [];
+  const sections = [];
+  const available = [
+    "<available-skills>",
+    ...autoSelectable.length > 0 ? [
+      "Scan before answering. Load the most specific matching skill; do not answer from memory when a skill fits. If none fits, do not load a skill."
+    ] : []
+  ];
+  for (const skill of autoSelectable) {
+    available.push(...formatSkillEntry(skill));
+  }
+  available.push("</available-skills>");
+  sections.push(available.join("\n"));
+  if (invokedExplicitOnly.length > 0) {
+    const userCallable = [
+      "<user-callable-skills>",
+      "The user's current message explicitly references this skill by name. Load it when relevant to the request."
+    ];
+    for (const skill of invokedExplicitOnly) {
+      userCallable.push(...formatSkillEntry(skill));
     }
-    lines.push("  </skill>");
+    userCallable.push("</user-callable-skills>");
+    sections.push(userCallable.join("\n"));
   }
-  lines.push("</available-skills>");
-  return lines.join("\n");
+  return sections.join("\n");
 }
 function formatLoadedSkillsForPrompt(skills) {
   if (skills.length === 0) {
@@ -2878,7 +2908,7 @@ function formatProviderCatalogForPrompt() {
     return null;
   }
   const lines = [
-    "Config keys and default targets per provider; use after a skill is loaded."
+    "Config keys and default targets per provider; use after a skill is loaded. Run authenticated provider commands directly after resolving target defaults; let the runtime handle auth pauses/resumes."
   ];
   for (const provider of providers) {
     lines.push(`- provider: ${escapeXml(provider.name)}`);
@@ -2898,7 +2928,7 @@ function formatActiveMcpCatalogsForPrompt(catalogs) {
     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`."
+    "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`. Put provider fields inside `arguments`."
   ];
   for (const catalog of catalogs) {
     lines.push("  <catalog>");
@@ -3008,12 +3038,8 @@ var TOOL_CALL_STYLE_RULES = [
   "- Keep tool-call explanations separate from final answers; final answers should report results, evidence, or blockers."
 ];
 var SKILL_POLICY_RULES = [
-  "- 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."
+  "- Only load skills listed in `<available-skills>`, `<user-callable-skills>`, or named by `<explicit-skill-trigger>`. Never guess or invent a skill name.",
+  "- Load one skill at a time. After `loadSkill`, follow the instructions in `<loaded-skills>`."
 ];
 var EXECUTION_CONTRACT_RULES = [
   "- Actionable request: act in this turn.",
@@ -3026,7 +3052,7 @@ var EXECUTION_CONTRACT_RULES = [
 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."
+  "- Runtime owns continuation and authorization notices; on resumed turns, answer with the final requested content only."
 ];
 var SLACK_ACTION_RULES = [
   "- Context-bound Slack tools use runtime-owned targets; do not invent channel, canvas, list, or message IDs.",
@@ -3123,7 +3149,7 @@ function buildContextSection(params) {
   if (configLines) {
     blocks.push(
       renderTag("configuration", [
-        "Ambient provider defaults; explicit targets win.",
+        "Ambient provider defaults; explicit targets win. Run `jr-rpc config get|set|unset|list` as standalone bash commands; do not chain with `cd`, `&&`, pipes, or provider commands.",
         ...configLines
       ])
     );
@@ -3135,16 +3161,21 @@ function buildContextSection(params) {
     ]);
   }
   if (params.invocation) {
-    blocks.push([
-      `<explicit-skill-trigger>/${escapeXml(params.invocation.skillName)}</explicit-skill-trigger>`
-    ]);
+    blocks.push(
+      renderTag("explicit-skill-trigger", [
+        "Treat this skill as selected. Load it unless the tool says it is unavailable.",
+        `/${escapeXml(params.invocation.skillName)}`
+      ])
+    );
   }
   const body = blocks.map((block) => block.join("\n")).join("\n\n");
   return renderTagBlock("context", body);
 }
 function buildCapabilitiesSection(params) {
   const blocks = [];
-  blocks.push(formatAvailableSkillsForPrompt(params.availableSkills));
+  blocks.push(
+    formatAvailableSkillsForPrompt(params.availableSkills, params.invocation)
+  );
   blocks.push(formatLoadedSkillsForPrompt(params.activeSkills));
   const activeCatalogs = formatActiveMcpCatalogsForPrompt(
     params.activeMcpCatalogs
@@ -3181,6 +3212,7 @@ function buildTurnContextPrompt(params) {
       availableSkills: params.availableSkills,
       activeSkills: params.activeSkills,
       activeMcpCatalogs: params.activeMcpCatalogs ?? [],
+      invocation: params.invocation,
       toolGuidance: params.toolGuidance ?? []
     }),
     buildContextSection({
@@ -4442,6 +4474,16 @@ function createBashTool() {
 
 // src/chat/tools/sandbox/file-utils.ts
 import path4 from "path";
+
+// src/chat/tools/execution/tool-input-error.ts
+var ToolInputError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ToolInputError";
+  }
+};
+
+// src/chat/tools/sandbox/file-utils.ts
 var MAX_TEXT_CHARS = 6e4;
 var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([".git", "node_modules"]);
 function positiveInteger(value) {
@@ -4534,7 +4576,7 @@ function resolveWorkspacePath(input, fallback = ".") {
   const absolute = requested.startsWith("/") ? requested : path4.posix.join(SANDBOX_WORKSPACE_ROOT, requested);
   const normalized = path4.posix.normalize(absolute);
   if (normalized !== SANDBOX_WORKSPACE_ROOT && !normalized.startsWith(`${SANDBOX_WORKSPACE_ROOT}/`)) {
-    throw new Error(
+    throw new ToolInputError(
       `Path must stay within ${SANDBOX_WORKSPACE_ROOT}: ${requested}`
     );
   }
@@ -4733,16 +4775,16 @@ function buildCompactDiff(oldContent, newContent) {
 }
 function validateAndApplyTextEdits(content, edits, targetName) {
   if (!Array.isArray(edits) || edits.length === 0) {
-    throw new Error(`${targetName} requires at least one edit.`);
+    throw new ToolInputError(`${targetName} requires at least one edit.`);
   }
   const normalizedEdits = edits.map((edit, index) => {
     if (typeof edit.oldText !== "string" || edit.oldText.length === 0) {
-      throw new Error(
+      throw new ToolInputError(
         `edits[${index}].oldText must not be empty in ${targetName}.`
       );
     }
     if (typeof edit.newText !== "string") {
-      throw new Error(
+      throw new ToolInputError(
         `edits[${index}].newText must be a string in ${targetName}.`
       );
     }
@@ -4756,13 +4798,13 @@ function validateAndApplyTextEdits(content, edits, targetName) {
     const edit = normalizedEdits[index];
     const matchIndex = content.indexOf(edit.oldText);
     if (matchIndex === -1) {
-      throw new Error(
+      throw new ToolInputError(
         `Could not find edits[${index}] in ${targetName}. oldText must match exactly including whitespace and newlines.`
       );
     }
     const occurrences = countOccurrences(content, edit.oldText);
     if (occurrences > 1) {
-      throw new Error(
+      throw new ToolInputError(
         `Found ${occurrences} occurrences of edits[${index}] in ${targetName}. Each oldText must be unique.`
       );
     }
@@ -4778,7 +4820,7 @@ function validateAndApplyTextEdits(content, edits, targetName) {
     const previous = matchedEdits[index - 1];
     const current = matchedEdits[index];
     if (previous.matchIndex + previous.matchLength > current.matchIndex) {
-      throw new Error(
+      throw new ToolInputError(
         `edits[${previous.editIndex}] and edits[${current.editIndex}] overlap in ${targetName}. Merge overlapping replacements into one edit.`
       );
     }
@@ -4789,7 +4831,7 @@ function validateAndApplyTextEdits(content, edits, targetName) {
     newContent = newContent.slice(0, edit.matchIndex) + edit.newText + newContent.slice(edit.matchIndex + edit.matchLength);
   }
   if (newContent === content) {
-    throw new Error(`No changes made to ${targetName}.`);
+    throw new ToolInputError(`No changes made to ${targetName}.`);
   }
   return { baseContent: content, newContent };
 }
@@ -4801,7 +4843,17 @@ function prepareEditFileArguments(input) {
 }
 async function editFile(params) {
   const filePath = resolveWorkspacePath(params.path);
-  const rawContent = await params.fs.readFile(filePath, { encoding: "utf8" });
+  let rawContent;
+  try {
+    rawContent = await params.fs.readFile(filePath, { encoding: "utf8" });
+  } catch (error) {
+    if (isMissingPathError(error)) {
+      throw new ToolInputError(`File not found: ${params.path}`, {
+        cause: error
+      });
+    }
+    throw error;
+  }
   const { bom, text } = stripBom(rawContent);
   const lineEnding = detectLineEnding(text);
   const normalizedContent = normalizeToLf(text);
@@ -4993,7 +5045,16 @@ async function grepFiles(params) {
   const root = resolveWorkspacePath(params.path);
   const limit = positiveInteger(params.limit) ?? DEFAULT_GREP_LIMIT;
   const context = positiveInteger(params.context) ?? 0;
-  const regex = params.literal ? void 0 : new RegExp(params.pattern, params.ignoreCase ? "i" : "");
+  let regex;
+  if (!params.literal) {
+    try {
+      regex = new RegExp(params.pattern, params.ignoreCase ? "i" : "");
+    } catch (error) {
+      throw new ToolInputError(`Invalid regex pattern: ${params.pattern}`, {
+        cause: error
+      });
+    }
+  }
   const { files, missingPath, missingRoot } = await collectFiles({
     fs: params.fs,
     root,
@@ -5311,7 +5372,7 @@ async function listDir(params) {
     throw error;
   }
   if (!stat.isDirectory()) {
-    throw new Error(`Not a directory: ${params.path ?? "."}`);
+    throw new ToolInputError(`Not a directory: ${params.path ?? "."}`);
   }
   let entries;
   try {
@@ -8220,7 +8281,7 @@ var FETCH_TIMEOUT_MS = 8e3;
 var MAX_REDIRECTS = 3;
 var DEFAULT_MAX_CHARS = 6e3;
 var MAX_FETCH_CHARS = 12e3;
-var MAX_FETCH_BYTES = 256e3;
+var MAX_FETCH_BYTES = 1e6;
 
 // src/chat/tools/web/network.ts
 import dns from "dns/promises";
@@ -8488,37 +8549,120 @@ function normalizeWhitespace(text) {
 }
 function truncateAtWordBoundary(text, maxChars) {
   if (text.length <= maxChars) {
-    return text;
+    return { content: text, truncated: false };
   }
   const shortened = text.slice(0, maxChars);
   const lastSpace = shortened.lastIndexOf(" ");
   if (lastSpace > maxChars * 0.8) {
-    return `${shortened.slice(0, lastSpace).trimEnd()}...`;
+    return {
+      content: `${shortened.slice(0, lastSpace).trimEnd()}...`,
+      truncated: true
+    };
+  }
+  return { content: `${shortened.trimEnd()}...`, truncated: true };
+}
+function decodeHtmlEntities(value) {
+  return value.replace(/&quot;/g, '"').replace(/&#39;|&apos;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+}
+function extractTitle(html) {
+  const match = html.match(/<title\b[^>]*>([\s\S]*?)<\/title>/i);
+  const title = match ? normalizeWhitespace(decodeHtmlEntities(match[1])) : "";
+  return title.length > 0 ? title : void 0;
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function getBalancedElementHtml(args) {
+  const tagPattern = new RegExp(
+    `</?${escapeRegex(args.tagName)}\\b[^>]*>`,
+    "gi"
+  );
+  tagPattern.lastIndex = args.startIndex;
+  let depth = 0;
+  for (const match of args.html.matchAll(tagPattern)) {
+    const tag = match[0];
+    if (tag.startsWith("</")) {
+      depth -= 1;
+      if (depth === 0) {
+        return args.html.slice(args.startIndex, match.index + tag.length);
+      }
+      continue;
+    }
+    if (!tag.endsWith("/>")) {
+      depth += 1;
+    }
+  }
+  return void 0;
+}
+function findElementHtml(html, predicate) {
+  const openingTagPattern = /<([a-z][\w:-]*)\b[^>]*>/gi;
+  for (const match of html.matchAll(openingTagPattern)) {
+    const tagName = match[1];
+    if (!tagName || !predicate(tagName.toLowerCase(), match[0])) {
+      continue;
+    }
+    const balanced = getBalancedElementHtml({
+      html,
+      startIndex: match.index,
+      tagName
+    });
+    if (balanced) {
+      return balanced;
+    }
   }
-  return `${shortened.trimEnd()}...`;
+  return void 0;
+}
+function extractMainHtml(html) {
+  return findElementHtml(html, (tagName) => tagName === "main") ?? findElementHtml(html, (tagName) => tagName === "article") ?? findElementHtml(
+    html,
+    (_tagName, tag) => /\brole\s*=\s*(["'])main\1/i.test(tag)
+  ) ?? html;
 }
-function extractContent(body, contentType, maxChars) {
+function extractContentDetails(body, contentType, maxChars) {
   const loweredContentType = contentType.toLowerCase();
   const normalizedBody = body.trim();
   if (loweredContentType.includes("html")) {
     try {
-      const markdown = htmlToMarkdownConverter.translate(normalizedBody);
-      return truncateAtWordBoundary(normalizeWhitespace(markdown), maxChars);
+      const sourceHtml = extractMainHtml(normalizedBody);
+      const markdown = htmlToMarkdownConverter.translate(sourceHtml);
+      const normalizedMarkdown = normalizeWhitespace(markdown);
+      const truncated2 = truncateAtWordBoundary(normalizedMarkdown, maxChars);
+      return {
+        content: truncated2.content,
+        title: extractTitle(normalizedBody),
+        truncated: truncated2.truncated,
+        extractedChars: normalizedMarkdown.length
+      };
     } catch {
     }
   }
   if (loweredContentType.includes("json")) {
     try {
       const parsed = JSON.parse(normalizedBody);
-      return truncateAtWordBoundary(JSON.stringify(parsed, null, 2), maxChars);
+      const formatted = JSON.stringify(parsed, null, 2);
+      const truncated2 = truncateAtWordBoundary(formatted, maxChars);
+      return {
+        content: truncated2.content,
+        truncated: truncated2.truncated,
+        extractedChars: formatted.length
+      };
     } catch {
-      return truncateAtWordBoundary(
-        normalizeWhitespace(normalizedBody),
-        maxChars
-      );
+      const normalizedText2 = normalizeWhitespace(normalizedBody);
+      const truncated2 = truncateAtWordBoundary(normalizedText2, maxChars);
+      return {
+        content: truncated2.content,
+        truncated: truncated2.truncated,
+        extractedChars: normalizedText2.length
+      };
     }
   }
-  return truncateAtWordBoundary(normalizeWhitespace(normalizedBody), maxChars);
+  const normalizedText = normalizeWhitespace(normalizedBody);
+  const truncated = truncateAtWordBoundary(normalizedText, maxChars);
+  return {
+    content: truncated.content,
+    truncated: truncated.truncated,
+    extractedChars: normalizedText.length
+  };
 }
 async function extractWebFetchResponse(url, response, maxChars = DEFAULT_MAX_CHARS) {
   const safeMaxChars = Math.max(500, Math.min(maxChars, MAX_FETCH_CHARS));
@@ -8534,8 +8678,16 @@ async function extractWebFetchResponse(url, response, maxChars = DEFAULT_MAX_CHA
     FETCH_TIMEOUT_MS,
     "read"
   );
-  const text = extractContent(body, contentType, safeMaxChars);
-  return { url: url.toString(), content: text };
+  const extracted = extractContentDetails(body, contentType, safeMaxChars);
+  return {
+    url: url.toString(),
+    content: extracted.content,
+    ...extracted.title ? { title: extracted.title } : {},
+    content_type: contentType || "unknown",
+    source_bytes: Buffer.byteLength(body, "utf8"),
+    extracted_chars: extracted.extractedChars,
+    truncated: extracted.truncated
+  };
 }
 
 // src/chat/tools/web/fetch-tool.ts
@@ -8558,6 +8710,7 @@ function extractHttpStatusFromMessage(message) {
   return Number.isFinite(parsed) ? parsed : null;
 }
 function createWebFetchTool(hooks) {
+  const override = hooks.toolOverrides?.webFetch;
   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.",
     annotations: {
@@ -8579,6 +8732,9 @@ function createWebFetchTool(hooks) {
       )
     }),
     execute: async ({ url, max_chars }) => {
+      if (override?.execute) {
+        return override.execute({ url, max_chars });
+      }
       try {
         const safeUrl = await assertPublicUrl(url);
         const response = await withTimeout(
@@ -8671,7 +8827,7 @@ function isAuthFailure(message) {
   const normalized = message.toLowerCase();
   return normalized.includes("missing ai gateway credentials") || normalized.includes("authentication failed");
 }
-function createWebSearchTool() {
+function createWebSearchTool(override) {
   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.",
     annotations: {
@@ -8694,6 +8850,9 @@ function createWebSearchTool() {
       )
     }),
     execute: async ({ query, max_results }) => {
+      if (override?.execute) {
+        return override.execute({ query, max_results });
+      }
       const maxResults = max_results ?? 3;
       const model = process.env.AI_WEB_SEARCH_MODEL ?? DEFAULT_SEARCH_MODEL;
       const controller = new AbortController();
@@ -8827,7 +8986,7 @@ function createTools(availableSkills, hooks = {}, context) {
     findFiles: createFindFilesTool(),
     listDir: createListDirTool(),
     writeFile: createWriteFileTool(),
-    webSearch: createWebSearchTool(),
+    webSearch: createWebSearchTool(hooks.toolOverrides?.webSearch),
     webFetch: createWebFetchTool(hooks),
     imageGenerate: createImageGenerateTool(
       hooks,
@@ -8935,14 +9094,11 @@ function buildSandboxEgressNetworkPolicy() {
   }
   return { allow };
 }
-async function resolveSandboxCommandEnvironment(provider) {
+async function resolveSandboxCommandEnvironment() {
   const env = {};
   for (const plugin of getPluginProviders().sort(
     (left, right) => left.manifest.name.localeCompare(right.manifest.name)
   )) {
-    if (provider && plugin.manifest.name !== provider) {
-      continue;
-    }
     Object.assign(env, resolvePluginCommandEnv(plugin.manifest));
     const credentials = plugin.manifest.credentials;
     if (credentials) {
@@ -9213,6 +9369,14 @@ function isSnapshottingError(error) {
     return searchable.includes("sandbox_snapshotting") || searchable.includes("creating a snapshot") || searchable.includes("stopped shortly");
   });
 }
+function isSandboxCommandStreamInterruptedError(error) {
+  return findInErrorChain(error, (candidate) => {
+    if (!(candidate instanceof Error)) {
+      return false;
+    }
+    return candidate.name === "StreamError" && candidate.message.toLowerCase().includes("stream ended before command finished");
+  });
+}
 function wrapSandboxSetupError(error) {
   try {
     const details = getSandboxErrorDetails(error);
@@ -9258,6 +9422,25 @@ import { randomUUID as randomUUID4 } from "crypto";
 import { Sandbox } from "@vercel/sandbox";
 import { createBashTool as createBashTool2 } from "bash-tool";
 
+// src/chat/sandbox/fault-injection.ts
+var STREAM_INTERRUPT_FAULT_ENV = "JUNIOR_EVAL_FAULT_SANDBOX_BASH_STREAM_INTERRUPTS";
+function consumeSandboxBashStreamInterruptFault() {
+  if (process.env.JUNIOR_EVAL_ENABLE_FAULTS !== "1") {
+    return void 0;
+  }
+  const remaining = Number.parseInt(
+    process.env[STREAM_INTERRUPT_FAULT_ENV] ?? "0",
+    10
+  );
+  if (!Number.isFinite(remaining) || remaining <= 0) {
+    return void 0;
+  }
+  process.env[STREAM_INTERRUPT_FAULT_ENV] = String(remaining - 1);
+  return Object.assign(new Error("Stream ended before command finished"), {
+    name: "StreamError"
+  });
+}
+
 // src/chat/sandbox/skill-sync.ts
 import fs3 from "fs/promises";
 import path9 from "path";
@@ -9386,6 +9569,62 @@ function outputText(value) {
   fs.writeFileSync(process.stdout.fd, value);
 }
 
+const repoFiles = {
+  "packages/junior/src/chat/sandbox/egress-policy.ts": \`import { resolveAuthTokenPlaceholder } from "@/chat/plugins/auth/auth-token-placeholder";
+import { resolvePluginCommandEnv } from "@/chat/plugins/command-env";
+import { getPluginProviders } from "@/chat/plugins/registry";
+
+/** Build the policy that forwards provider requests back to Junior for credentials. */
+export function buildSandboxEgressNetworkPolicy() {
+  // Plugin credential domains are forwarded through the host so the sandbox can
+  // activate requester-bound credentials for the current turn.
+}
+
+/** Resolve non-secret command environment values for registered sandbox providers. */
+export async function resolveSandboxCommandEnvironment() {
+  const env = {};
+  for (const plugin of getPluginProviders()) {
+    Object.assign(env, resolvePluginCommandEnv(plugin.manifest));
+    const credentials = plugin.manifest.credentials;
+    if (credentials) {
+      env[credentials.authTokenEnv] = resolveAuthTokenPlaceholder(credentials);
+    }
+  }
+  return env;
+}
+\`,
+  "packages/junior/src/chat/plugins/registry.ts": \`import { createGitHubAppBroker } from "@/chat/plugins/auth/github-app-broker";
+
+export function createPluginBroker(provider, deps) {
+  const plugin = ensurePluginsLoaded().pluginsByName.get(provider);
+  const { credentials, name } = plugin.manifest;
+  if (credentials.type === "github-app") {
+    return createGitHubAppBroker(plugin.manifest, credentials);
+  }
+}
+\`,
+  "packages/junior-github/plugin.yaml": \`name: github
+description: GitHub issue, pull request, and repository workflows via GitHub App
+
+credentials:
+  type: github-app
+  domains:
+    - api.github.com
+    - github.com
+  auth-token-env: GITHUB_TOKEN
+  auth-token-placeholder: ghp_host_managed_credential
+\`,
+};
+
+function writeRepoFixture(targetDir) {
+  fs.mkdirSync(targetDir, { recursive: true });
+  for (const [relativePath, content] of Object.entries(repoFiles)) {
+    const filePath = path.join(targetDir, relativePath);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content);
+  }
+}
+
 function fallbackToRealGh() {
   for (const binary of fallbackBinaries) {
     if (!fs.existsSync(binary)) {
@@ -9433,9 +9672,33 @@ if (args[0] === "repo" && args[1] === "view") {
   process.exit(0);
 }
 
+if (args[0] === "repo" && args[1] === "clone") {
+  const positionals = getPositionals();
+  const repo = positionals[2] || repoValue();
+  const targetDir = positionals[3] || repo.split("/").pop() || "repo";
+  writeRepoFixture(path.resolve(process.cwd(), targetDir));
+  outputText("Cloning into '" + targetDir + "'...\\n");
+  process.exit(0);
+}
+
 if (args[0] === "api") {
   const positionals = getPositionals();
   const route = positionals[1] || "";
+  if (route.includes("/git/trees/")) {
+    const paths = Object.keys(repoFiles);
+    const jq = getFlag("--jq");
+    if (jq && jq.includes(".tree[].path")) {
+      outputText(paths.join("\\n") + "\\n");
+    } else {
+      outputJson({
+        tree: paths.map((filePath) => ({
+          path: filePath,
+          type: "blob",
+        })),
+      });
+    }
+    process.exit(0);
+  }
   if (route.includes("/comments")) {
     outputJson([]);
     process.exit(0);
@@ -9887,6 +10150,15 @@ function parseKeepAliveMs() {
   );
   return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
 }
+function getCommandStreamInterruptedResult() {
+  return {
+    stdout: "",
+    stderr: "Command stream ended before the command finished. The command may still have produced side effects; inspect the workspace or rerun only if it is safe.",
+    exitCode: 125,
+    stdoutTruncated: false,
+    stderrTruncated: false
+  };
+}
 function createSandboxSessionManager(options) {
   let sandbox = null;
   let sandboxIdHint = options?.sandboxId;
@@ -10298,6 +10570,10 @@ function createSandboxSessionManager(options) {
             timedOut = true;
             controller.abort();
           }, input.timeoutMs) : void 0;
+          const streamInterruptFault = consumeSandboxBashStreamInterruptFault();
+          if (streamInterruptFault) {
+            throw streamInterruptFault;
+          }
           const commandResult2 = await sandboxInstance.runCommand({
             cmd: "bash",
             args: ["-c", script],
@@ -10317,6 +10593,9 @@ function createSandboxSessionManager(options) {
               timedOut: true
             };
           }
+          if (isSandboxCommandStreamInterruptedError(error)) {
+            return getCommandStreamInterruptedResult();
+          }
           throw error;
         } finally {
           if (timeoutId) {
@@ -10426,10 +10705,7 @@ function createSandboxExecutor(options) {
     sandboxDependencyProfileHash: options?.sandboxDependencyProfileHash,
     timeoutMs: options?.timeoutMs,
     traceContext,
-    commandEnv: credentialEgress ? async () => {
-      const provider = credentialEgress.activeProvider?.();
-      return provider ? await resolveSandboxCommandEnvironment(provider) : {};
-    } : void 0,
+    commandEnv: credentialEgress ? async () => await resolveSandboxCommandEnvironment() : void 0,
     createNetworkPolicy: credentialEgress ? buildSandboxEgressNetworkPolicy : void 0,
     beforeCommand: authorizeSandboxEgressForCommand,
     afterCommand: clearSandboxEgressForCommand,
@@ -10513,7 +10789,7 @@ function createSandboxExecutor(options) {
   const executeReadFileTool = async (rawInput) => {
     const filePath = String(rawInput.path ?? "").trim();
     if (!filePath) {
-      throw new Error("path is required");
+      throw new ToolInputError("path is required");
     }
     const offset = positiveInteger(rawInput.offset);
     const limit = positiveInteger(rawInput.limit);
@@ -10586,7 +10862,7 @@ function createSandboxExecutor(options) {
   const executeWriteFileTool = async (rawInput) => {
     const filePath = String(rawInput.path ?? "").trim();
     if (!filePath) {
-      throw new Error("path is required");
+      throw new ToolInputError("path is required");
     }
     const content = String(rawInput.content ?? "");
     logSandboxBootRequest("tool.writeFile", {
@@ -10620,10 +10896,10 @@ function createSandboxExecutor(options) {
   const executeEditFileTool = async (rawInput) => {
     const filePath = String(rawInput.path ?? "").trim();
     if (!filePath) {
-      throw new Error("path is required");
+      throw new ToolInputError("path is required");
     }
     if (!Array.isArray(rawInput.edits)) {
-      throw new Error("edits is required");
+      throw new ToolInputError("edits is required");
     }
     logSandboxBootRequest("tool.editFile", {
       "file.path": filePath
@@ -10651,7 +10927,7 @@ function createSandboxExecutor(options) {
   const executeGrepTool = async (rawInput) => {
     const pattern = String(rawInput.pattern ?? "");
     if (!pattern) {
-      throw new Error("pattern is required");
+      throw new ToolInputError("pattern is required");
     }
     logSandboxBootRequest("tool.grep");
     const contextLines = positiveInteger(rawInput.context);
@@ -10683,7 +10959,7 @@ function createSandboxExecutor(options) {
   const executeFindFilesTool = async (rawInput) => {
     const pattern = String(rawInput.pattern ?? "");
     if (!pattern) {
-      throw new Error("pattern is required");
+      throw new ToolInputError("pattern is required");
     }
     logSandboxBootRequest("tool.findFiles");
     const limit = positiveInteger(rawInput.limit);
@@ -10732,7 +11008,7 @@ function createSandboxExecutor(options) {
     const bashCommand = params.toolName === "bash" ? String(rawInput.command ?? "").trim() : void 0;
     if (params.toolName === "bash") {
       if (!bashCommand) {
-        throw new Error("command is required");
+        throw new ToolInputError("command is required");
       }
       if (options?.runBashCustomCommand) {
         const custom = await options.runBashCustomCommand(bashCommand);
@@ -10934,6 +11210,28 @@ var AGENT_TURN_SESSION_TTL_MS = 24 * 60 * 60 * 1e3;
 function agentTurnSessionKey(conversationId, sessionId) {
   return `${AGENT_TURN_SESSION_PREFIX}:${conversationId}:${sessionId}`;
 }
+function toFiniteNonNegativeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : void 0;
+}
+function parseAgentTurnUsage(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const usage = {};
+  for (const field of [
+    "inputTokens",
+    "outputTokens",
+    "cachedInputTokens",
+    "cacheCreationTokens",
+    "totalTokens"
+  ]) {
+    const count = toFiniteNonNegativeNumber(value[field]);
+    if (count !== void 0) {
+      usage[field] = count;
+    }
+  }
+  return Object.keys(usage).length > 0 ? usage : void 0;
+}
 function parseAgentTurnSessionCheckpoint(value) {
   if (typeof value !== "string") {
     return void 0;
@@ -10952,6 +11250,10 @@ function parseAgentTurnSessionCheckpoint(value) {
     const sliceId = parsed.sliceId;
     const checkpointVersion = parsed.checkpointVersion;
     const updatedAtMs = parsed.updatedAtMs;
+    const cumulativeDurationMs = toFiniteNonNegativeNumber(
+      parsed.cumulativeDurationMs
+    );
+    const cumulativeUsage = parseAgentTurnUsage(parsed.cumulativeUsage);
     if (typeof conversationId !== "string" || typeof sessionId !== "string" || typeof sliceId !== "number" || typeof checkpointVersion !== "number" || typeof updatedAtMs !== "number") {
       return void 0;
     }
@@ -10962,6 +11264,8 @@ function parseAgentTurnSessionCheckpoint(value) {
       sliceId,
       state: status,
       updatedAtMs,
+      ...cumulativeDurationMs !== void 0 ? { cumulativeDurationMs } : {},
+      ...cumulativeUsage ? { cumulativeUsage } : {},
       piMessages: Array.isArray(parsed.piMessages) ? parsed.piMessages : [],
       ...Array.isArray(parsed.loadedSkillNames) ? {
         loadedSkillNames: parsed.loadedSkillNames.filter(
@@ -10999,6 +11303,13 @@ async function upsertAgentTurnSessionCheckpoint(args) {
     state: args.state,
     updatedAtMs: Date.now(),
     piMessages: Array.isArray(args.piMessages) ? args.piMessages : [],
+    ...typeof args.cumulativeDurationMs === "number" && Number.isFinite(args.cumulativeDurationMs) ? {
+      cumulativeDurationMs: Math.max(
+        0,
+        Math.floor(args.cumulativeDurationMs)
+      )
+    } : {},
+    ...args.cumulativeUsage ? { cumulativeUsage: args.cumulativeUsage } : {},
     ...Array.isArray(args.loadedSkillNames) ? {
       loadedSkillNames: args.loadedSkillNames.filter(
         (value) => typeof value === "string"
@@ -11030,6 +11341,8 @@ async function supersedeAgentTurnSessionCheckpoint(args) {
     sliceId: existing.sliceId,
     state: "superseded",
     piMessages: existing.piMessages,
+    cumulativeDurationMs: existing.cumulativeDurationMs,
+    cumulativeUsage: existing.cumulativeUsage,
     loadedSkillNames: existing.loadedSkillNames,
     resumeReason: existing.resumeReason,
     resumedFromSliceId: existing.resumedFromSliceId,
@@ -11291,6 +11604,11 @@ function createPluginAuthOrchestration(deps, abortAgent) {
 }
 
 // src/chat/tools/execution/tool-error-handler.ts
+function getToolErrorType(error) {
+  if (error instanceof McpToolError) return "tool_error";
+  if (error instanceof ToolInputError) return "tool_input_error";
+  return error instanceof Error ? error.name : "tool_execution_error";
+}
 function getToolErrorAttributes(error) {
   if (!(error instanceof SlackActionError)) {
     return {};
@@ -11304,7 +11622,7 @@ function getToolErrorAttributes(error) {
   };
 }
 function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, traceContext) {
-  const errorType = getMcpAwareErrorType(error, "tool_execution_error");
+  const errorType = getToolErrorType(error);
   const errorMessage = getMcpAwareErrorMessage(error);
   setSpanAttributes({
     "error.type": errorType,
@@ -11343,7 +11661,8 @@ function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, trac
       "Agent tool call failed"
     );
   }
-  if (!(error instanceof McpToolError)) {
+  const isExpectedToolFailure = error instanceof McpToolError || error instanceof ToolInputError;
+  if (!isExpectedToolFailure) {
     logException(
       error,
       "agent_tool_call_failed",
@@ -11898,7 +12217,95 @@ function toAgentThinkingLevel(level) {
   }
 }
 
+// src/chat/usage.ts
+var COMPONENT_USAGE_FIELDS = [
+  "inputTokens",
+  "outputTokens",
+  "cachedInputTokens",
+  "cacheCreationTokens"
+];
+function hasAgentTurnUsage(usage) {
+  return Boolean(
+    usage && Object.values(usage).some(
+      (value) => typeof value === "number" && Number.isFinite(value)
+    )
+  );
+}
+function getFiniteCount(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : void 0;
+}
+function getComponentTotal(usage) {
+  let total;
+  for (const field of COMPONENT_USAGE_FIELDS) {
+    const value = getFiniteCount(usage[field]);
+    if (value === void 0) continue;
+    total = (total ?? 0) + value;
+  }
+  return total;
+}
+function addAgentTurnUsage(...usages) {
+  const components = {};
+  let componentTotal;
+  let totalOnlyTokens;
+  for (const usage of usages) {
+    if (!usage) continue;
+    const usageComponentTotal = getComponentTotal(usage);
+    if (usageComponentTotal !== void 0) {
+      componentTotal = (componentTotal ?? 0) + usageComponentTotal;
+      for (const field of COMPONENT_USAGE_FIELDS) {
+        const value = getFiniteCount(usage[field]);
+        if (value === void 0) continue;
+        components[field] = (components[field] ?? 0) + value;
+      }
+      continue;
+    }
+    const totalTokens = getFiniteCount(usage.totalTokens);
+    if (totalTokens !== void 0) {
+      totalOnlyTokens = (totalOnlyTokens ?? 0) + totalTokens;
+    }
+  }
+  if (totalOnlyTokens !== void 0) {
+    return {
+      totalTokens: totalOnlyTokens + (componentTotal ?? 0)
+    };
+  }
+  return hasAgentTurnUsage(components) ? components : void 0;
+}
+
 // src/chat/services/turn-checkpoint.ts
+function logCheckpointError(error, eventName, args, attributes, message) {
+  logException(
+    error,
+    eventName,
+    {
+      slackThreadId: args.logContext.threadId,
+      slackUserId: args.logContext.requesterId,
+      slackChannelId: args.logContext.channelId,
+      runId: args.logContext.runId,
+      assistantUserName: args.logContext.assistantUserName,
+      modelId: args.logContext.modelId
+    },
+    {
+      "app.ai.resume_conversation_id": args.conversationId,
+      "app.ai.resume_session_id": args.sessionId,
+      ...attributes
+    },
+    message
+  );
+}
+function addDurationMs(prior, current) {
+  const total = [prior, current].reduce((sum, value) => {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      return sum;
+    }
+    return (sum ?? 0) + Math.max(0, Math.floor(value));
+  }, void 0);
+  return total;
+}
+function isContinuableBoundary(messages) {
+  const lastRole = getPiMessageRole(messages.at(-1));
+  return lastRole === "user" || lastRole === "toolResult";
+}
 async function loadTurnCheckpoint(ctx) {
   const canUseTurnSession = Boolean(ctx.conversationId && ctx.sessionId);
   const existingCheckpoint = canUseTurnSession && ctx.conversationId && ctx.sessionId ? await getAgentTurnSessionCheckpoint(ctx.conversationId, ctx.sessionId) : void 0;
@@ -11912,15 +12319,70 @@ async function loadTurnCheckpoint(ctx) {
     existingCheckpoint
   };
 }
+async function persistRunningCheckpoint(args) {
+  if (args.messages.length === 0 || !isContinuableBoundary(args.messages)) {
+    return;
+  }
+  try {
+    const latestCheckpoint = await getAgentTurnSessionCheckpoint(
+      args.conversationId,
+      args.sessionId
+    );
+    await upsertAgentTurnSessionCheckpoint({
+      conversationId: args.conversationId,
+      cumulativeDurationMs: latestCheckpoint?.cumulativeDurationMs,
+      cumulativeUsage: latestCheckpoint?.cumulativeUsage,
+      sessionId: args.sessionId,
+      sliceId: args.sliceId,
+      state: "running",
+      piMessages: args.messages,
+      loadedSkillNames: args.loadedSkillNames
+    });
+  } catch (checkpointError) {
+    logCheckpointError(
+      checkpointError,
+      "agent_turn_running_checkpoint_failed",
+      args,
+      {
+        "app.ai.resume_slice_id": args.sliceId
+      },
+      "Failed to persist running turn checkpoint"
+    );
+  }
+}
 async function persistCompletedCheckpoint(args) {
-  await upsertAgentTurnSessionCheckpoint({
-    conversationId: args.conversationId,
-    sessionId: args.sessionId,
-    sliceId: args.sliceId,
-    state: "completed",
-    piMessages: args.allMessages,
-    loadedSkillNames: args.loadedSkillNames
-  });
+  try {
+    const latestCheckpoint = await getAgentTurnSessionCheckpoint(
+      args.conversationId,
+      args.sessionId
+    );
+    await upsertAgentTurnSessionCheckpoint({
+      conversationId: args.conversationId,
+      cumulativeDurationMs: addDurationMs(
+        latestCheckpoint?.cumulativeDurationMs,
+        args.currentDurationMs
+      ),
+      cumulativeUsage: addAgentTurnUsage(
+        latestCheckpoint?.cumulativeUsage,
+        args.currentUsage
+      ),
+      sessionId: args.sessionId,
+      sliceId: args.sliceId,
+      state: "completed",
+      piMessages: args.allMessages,
+      loadedSkillNames: args.loadedSkillNames
+    });
+  } catch (checkpointError) {
+    logCheckpointError(
+      checkpointError,
+      "agent_turn_completed_checkpoint_failed",
+      args,
+      {
+        "app.ai.resume_slice_id": args.sliceId
+      },
+      "Failed to persist completed turn checkpoint"
+    );
+  }
 }
 async function persistAuthPauseCheckpoint(args) {
   const nextSliceId = args.currentSliceId + 1;
@@ -11934,6 +12396,14 @@ async function persistAuthPauseCheckpoint(args) {
     );
     await upsertAgentTurnSessionCheckpoint({
       conversationId: args.conversationId,
+      cumulativeDurationMs: addDurationMs(
+        latestCheckpoint?.cumulativeDurationMs,
+        args.currentDurationMs
+      ),
+      cumulativeUsage: addAgentTurnUsage(
+        latestCheckpoint?.cumulativeUsage,
+        args.currentUsage
+      ),
       sessionId: args.sessionId,
       sliceId: nextSliceId,
       state: "awaiting_resume",
@@ -11944,20 +12414,11 @@ async function persistAuthPauseCheckpoint(args) {
       errorMessage: args.errorMessage
     });
   } catch (checkpointError) {
-    logException(
+    logCheckpointError(
       checkpointError,
       "agent_turn_auth_resume_checkpoint_failed",
+      args,
       {
-        slackThreadId: args.logContext.threadId,
-        slackUserId: args.logContext.requesterId,
-        slackChannelId: args.logContext.channelId,
-        runId: args.logContext.runId,
-        assistantUserName: args.logContext.assistantUserName,
-        modelId: args.logContext.modelId
-      },
-      {
-        "app.ai.resume_conversation_id": args.conversationId,
-        "app.ai.resume_session_id": args.sessionId,
         "app.ai.resume_from_slice_id": args.currentSliceId,
         "app.ai.resume_next_slice_id": nextSliceId
       },
@@ -11978,6 +12439,14 @@ async function persistTimeoutCheckpoint(args) {
     );
     return await upsertAgentTurnSessionCheckpoint({
       conversationId: args.conversationId,
+      cumulativeDurationMs: addDurationMs(
+        latestCheckpoint?.cumulativeDurationMs,
+        args.currentDurationMs
+      ),
+      cumulativeUsage: addAgentTurnUsage(
+        latestCheckpoint?.cumulativeUsage,
+        args.currentUsage
+      ),
       sessionId: args.sessionId,
       sliceId: nextSliceId,
       state: "awaiting_resume",
@@ -11988,20 +12457,11 @@ async function persistTimeoutCheckpoint(args) {
       errorMessage: args.errorMessage
     });
   } catch (checkpointError) {
-    logException(
+    logCheckpointError(
       checkpointError,
       "agent_turn_timeout_resume_checkpoint_failed",
+      args,
       {
-        slackThreadId: args.logContext.threadId,
-        slackUserId: args.logContext.requesterId,
-        slackChannelId: args.logContext.channelId,
-        runId: args.logContext.runId,
-        assistantUserName: args.logContext.assistantUserName,
-        modelId: args.logContext.modelId
-      },
-      {
-        "app.ai.resume_conversation_id": args.conversationId,
-        "app.ai.resume_session_id": args.sessionId,
         "app.ai.resume_from_slice_id": args.currentSliceId,
         "app.ai.resume_next_slice_id": nextSliceId
       },
@@ -12123,6 +12583,12 @@ function trimRouterAttachmentText(text) {
   }
   return normalized.length <= MAX_ROUTER_ATTACHMENT_PREVIEW_CHARS ? normalized : `${normalized.slice(0, MAX_ROUTER_ATTACHMENT_PREVIEW_CHARS)}...`;
 }
+function extractSliceUsage(messages, beforeMessageCount) {
+  const usage = extractGenAiUsageSummary(
+    ...messages.slice(beforeMessageCount).filter(isAssistantMessage)
+  );
+  return hasAgentTurnUsage(usage) ? usage : void 0;
+}
 function supportsRouterTextPreview(mediaType) {
   const baseMediaType = mediaType.split(";", 1)[0]?.trim().toLowerCase();
   if (!baseMediaType) {
@@ -12277,6 +12743,14 @@ async function generateAssistantReply(messageText, context = {}) {
   let timedOut = false;
   let turnUsage;
   let thinkingSelection;
+  const checkpointLogContext = {
+    threadId: context.correlation?.threadId,
+    requesterId: context.correlation?.requesterId,
+    channelId: context.correlation?.channelId,
+    runId: context.correlation?.runId,
+    assistantUserName: botConfig.userName,
+    modelId: botConfig.modelId
+  };
   const getSandboxMetadata = () => sandboxExecutor ? {
     sandboxId: sandboxExecutor.getSandboxId(),
     sandboxDependencyProfileHash: sandboxExecutor.getDependencyProfileHash()
@@ -12365,8 +12839,7 @@ async function generateAssistantReply(messageText, context = {}) {
       sandboxDependencyProfileHash: context.sandbox?.sandboxDependencyProfileHash,
       traceContext: spanContext,
       credentialEgress: requesterId ? {
-        requesterId,
-        activeProvider: () => skillSandbox.getActiveSkill()?.pluginProvider
+        requesterId
       } : void 0,
       onSandboxAcquired: async (sandbox2) => {
         lastKnownSandboxId = sandbox2.sandboxId;
@@ -12542,8 +13015,11 @@ async function generateAssistantReply(messageText, context = {}) {
     });
     const toolChannelId = context.toolChannelId ?? context.correlation?.channelId;
     const channelCapabilities = resolveChannelCapabilities(toolChannelId);
+    const loadableSkills = availableSkills.filter(
+      (skill) => skill.disableModelInvocation !== true || skill.name === invokedSkill?.name
+    );
     const tools = createTools(
-      availableSkills,
+      loadableSkills,
       {
         getGeneratedFile: (filename) => generatedFiles.find((file) => file.filename === filename),
         onGeneratedArtifactFiles: (files) => {
@@ -12707,7 +13183,23 @@ async function generateAssistantReply(messageText, context = {}) {
     });
     let hasEmittedText = false;
     let needsSeparator = false;
+    const persistSafeBoundary = async (messages) => {
+      if (!checkpointState.canUseTurnSession || !sessionConversationId || !sessionId) {
+        return;
+      }
+      await persistRunningCheckpoint({
+        conversationId: sessionConversationId,
+        sessionId,
+        sliceId: currentSliceId,
+        messages,
+        loadedSkillNames: loadedSkillNamesForResume,
+        logContext: checkpointLogContext
+      });
+    };
     const unsubscribe = agent.subscribe((event) => {
+      if (event.type === "turn_end" && event.toolResults.length > 0) {
+        return persistSafeBoundary([...agent.state.messages]);
+      }
       if (event.type === "message_start") {
         Promise.resolve(context.onAssistantMessageStart?.()).catch((error) => {
           logWarn(
@@ -12760,11 +13252,18 @@ async function generateAssistantReply(messageText, context = {}) {
         spanContext,
         async () => {
           let promptResult;
-          const promptPromise = resumedFromCheckpoint ? agent.continue() : agent.prompt({
+          const freshPromptMessage = {
             role: "user",
             content: promptContentParts,
             timestamp: Date.now()
-          });
+          };
+          if (!resumedFromCheckpoint) {
+            await persistSafeBoundary([
+              ...agent.state.messages,
+              freshPromptMessage
+            ]);
+          }
+          const promptPromise = resumedFromCheckpoint ? agent.continue() : agent.prompt(freshPromptMessage);
           let timeoutId;
           const timeoutPromise = new Promise((_, reject) => {
             timeoutId = setTimeout(() => {
@@ -12817,9 +13316,7 @@ async function generateAssistantReply(messageText, context = {}) {
             agent.state,
             ...outputMessages
           );
-          turnUsage = Object.values(usageSummary).some(
-            (value) => value !== void 0
-          ) ? usageSummary : void 0;
+          turnUsage = hasAgentTurnUsage(usageSummary) ? usageSummary : void 0;
           setSpanAttributes({
             ...outputMessagesAttribute ? { "gen_ai.output.messages": outputMessagesAttribute } : {},
             ...extractGenAiUsageAttributes(usageSummary)
@@ -12843,10 +13340,13 @@ async function generateAssistantReply(messageText, context = {}) {
     if (checkpointState.canUseTurnSession && sessionConversationId && sessionId) {
       await persistCompletedCheckpoint({
         conversationId: sessionConversationId,
+        currentDurationMs: Date.now() - replyStartedAtMs,
+        currentUsage: turnUsage,
         sessionId,
         sliceId: currentSliceId,
         allMessages: agent.state.messages,
-        loadedSkillNames: activeSkills.map((skill) => skill.name)
+        loadedSkillNames: activeSkills.map((skill) => skill.name),
+        logContext: checkpointLogContext
       });
     }
     return buildTurnResult({
@@ -12872,21 +13372,17 @@ async function generateAssistantReply(messageText, context = {}) {
     });
   } catch (error) {
     if (timedOut && timeoutResumeConversationId && timeoutResumeSessionId) {
+      turnUsage = turnUsage ?? extractSliceUsage(timeoutResumeMessages, beforeMessageCount);
       const checkpoint = await persistTimeoutCheckpoint({
         conversationId: timeoutResumeConversationId,
         sessionId: timeoutResumeSessionId,
         currentSliceId: timeoutResumeSliceId,
+        currentDurationMs: Date.now() - replyStartedAtMs,
+        currentUsage: turnUsage,
         messages: timeoutResumeMessages,
         loadedSkillNames: loadedSkillNamesForResume,
         errorMessage: error instanceof Error ? error.message : String(error),
-        logContext: {
-          threadId: context.correlation?.threadId,
-          requesterId: context.correlation?.requesterId,
-          channelId: context.correlation?.channelId,
-          runId: context.correlation?.runId,
-          assistantUserName: botConfig.userName,
-          modelId: botConfig.modelId
-        }
+        logContext: checkpointLogContext
       });
       if (checkpoint) {
         throw new RetryableTurnError(
@@ -12903,28 +13399,21 @@ async function generateAssistantReply(messageText, context = {}) {
     }
     if (error instanceof AuthorizationPauseError && timeoutResumeConversationId && timeoutResumeSessionId) {
       if (!turnUsage && timeoutResumeMessages.length > 0) {
-        const fallbackUsage = extractGenAiUsageSummary(
-          ...timeoutResumeMessages.slice(beforeMessageCount).filter(isAssistantMessage)
+        turnUsage = extractSliceUsage(
+          timeoutResumeMessages,
+          beforeMessageCount
         );
-        turnUsage = Object.values(fallbackUsage).some(
-          (value) => value !== void 0
-        ) ? fallbackUsage : void 0;
       }
       const nextSliceId = await persistAuthPauseCheckpoint({
         conversationId: timeoutResumeConversationId,
         sessionId: timeoutResumeSessionId,
         currentSliceId: timeoutResumeSliceId,
+        currentDurationMs: Date.now() - replyStartedAtMs,
+        currentUsage: turnUsage,
         messages: timeoutResumeMessages,
         loadedSkillNames: loadedSkillNamesForResume,
         errorMessage: error.message,
-        logContext: {
-          threadId: context.correlation?.threadId,
-          requesterId: context.correlation?.requesterId,
-          channelId: context.correlation?.channelId,
-          runId: context.correlation?.runId,
-          assistantUserName: botConfig.userName,
-          modelId: botConfig.modelId
-        }
+        logContext: checkpointLogContext
       });
       throw new RetryableTurnError(
         error.kind === "plugin" ? "plugin_auth_resume" : "mcp_auth_resume",
@@ -13074,9 +13563,10 @@ function finalizeFailedTurnReply(args) {
     ),
     capture.eventName
   );
+  const providerPartialText = args.reply.diagnostics.outcome === "provider_error" ? args.reply.text.trim() : "";
   return {
     ...args.reply,
-    text: buildTurnFailureResponse(eventId),
+    text: providerPartialText ? `${providerPartialText}${getInterruptionMarker()}` : buildTurnFailureResponse(eventId),
     deliveryMode: "thread",
     deliveryPlan: {
       mode: "thread",
@@ -13086,12 +13576,6 @@ function finalizeFailedTurnReply(args) {
   };
 }
 
-// src/chat/services/turn-continuation-response.ts
-var TURN_CONTINUATION_RESPONSE = "I'm still working on this in the background. I'll post the final response here when it finishes.";
-function buildTurnContinuationResponse() {
-  return TURN_CONTINUATION_RESPONSE;
-}
-
 // src/chat/slack/assistant-thread/status-render.ts
 var DEFAULT_STATUS_CONTEXTS = {
   thinking: "\u2026",
@@ -13451,16 +13935,12 @@ function createSlackWebApiAssistantStatusSession(args) {
 }
 
 // src/chat/slack/footer.ts
-var SENTRY_CONVERSATION_SEARCH_STATS_PERIOD = "14d";
 function escapeSlackMrkdwn(text) {
   return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
 function escapeSlackLinkUrl(url) {
   return url.replaceAll("&", "&amp;").replaceAll("<", "%3C").replaceAll(">", "%3E");
 }
-function quoteSentrySearchValue(value) {
-  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
-}
 function getSentryOrgSlug() {
   const slug = process.env.SENTRY_ORG_SLUG?.trim();
   return slug || void 0;
@@ -13476,7 +13956,7 @@ function buildSentryWebBaseUrl(dsn) {
   const path11 = dsn.path ? `/${dsn.path}` : "";
   return `${dsn.protocol}://${dsn.host}${port}${path11}`;
 }
-function getSentryConversationSearchUrl(conversationId) {
+function getSentryConversationUrl(conversationId) {
   const client2 = sentry_exports.getClient();
   const dsn = client2?.getDsn();
   if (!dsn?.host || !dsn.projectId) {
@@ -13486,18 +13966,14 @@ function getSentryConversationSearchUrl(conversationId) {
   if (!orgSlug) {
     return void 0;
   }
+  const encodedId = encodeURIComponent(conversationId);
   const params = new URLSearchParams();
-  params.set(
-    "query",
-    `gen_ai.conversation.id:${quoteSentrySearchValue(conversationId)}`
-  );
   params.set("project", dsn.projectId);
-  params.set("statsPeriod", SENTRY_CONVERSATION_SEARCH_STATS_PERIOD);
-  const search = `explore/traces/?${params.toString()}`;
+  const path11 = `explore/conversations/${encodedId}/?${params.toString()}`;
   if (isSentrySaasDsnHost(dsn.host)) {
-    return `https://${orgSlug}.sentry.io/${search}`;
+    return `https://${orgSlug}.sentry.io/${path11}`;
   }
-  return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${search}`;
+  return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path11}`;
 }
 function formatSlackTokenCount(value) {
   if (value >= 1e6) {
@@ -13552,7 +14028,7 @@ function buildSlackReplyFooter(args) {
       label: "ID",
       value: conversationId
     };
-    const conversationUrl = getSentryConversationSearchUrl(conversationId);
+    const conversationUrl = getSentryConversationUrl(conversationId);
     if (conversationUrl) {
       idItem.url = conversationUrl;
     }
@@ -13748,6 +14224,25 @@ async function postSlackApiReplyPosts(args) {
   return lastPostedMessageTs;
 }
 
+// src/chat/services/turn-continuation-response.ts
+var TURN_CONTINUATION_RESPONSE = "I'm still working on this in the background. I'll post the final response here when it finishes.";
+function buildTurnContinuationResponse() {
+  return TURN_CONTINUATION_RESPONSE;
+}
+
+// src/chat/slack/turn-continuation-notice.ts
+function buildSlackTurnContinuationNotice(args) {
+  const text = buildTurnContinuationResponse();
+  const footer = buildSlackReplyFooter({
+    conversationId: args.conversationId
+  });
+  const blocks = footer ? buildSlackReplyBlocks(text, footer) : void 0;
+  return {
+    text,
+    ...blocks ? { blocks } : {}
+  };
+}
+
 // src/chat/slack/errors.ts
 function getSlackApiErrorCode(error) {
   if (!error || typeof error !== "object") {
@@ -14079,11 +14574,14 @@ async function postResumeFailureReply(args) {
   }
 }
 async function postTurnContinuationNoticeBestEffort(args) {
+  const notice = buildSlackTurnContinuationNotice({
+    conversationId: args.resumeArgs.replyContext?.correlation?.conversationId ?? args.lockKey
+  });
   try {
     await postSlackMessage({
       channelId: args.resumeArgs.channelId,
       threadTs: args.resumeArgs.threadTs,
-      text: buildTurnContinuationResponse()
+      ...notice
     });
   } catch (error) {
     logException(
@@ -14187,6 +14685,10 @@ async function resumeSlackTurn(args) {
     status.start();
     const generateReply = args.generateReply ?? generateAssistantReply;
     const replyContext = createResumeReplyContext(args, status);
+    const priorCheckpoint = replyContext.correlation?.conversationId && replyContext.correlation?.turnId ? await getAgentTurnSessionCheckpoint(
+      replyContext.correlation.conversationId,
+      replyContext.correlation.turnId
+    ) : void 0;
     const replyPromise = generateReply(args.messageText, replyContext);
     const replyTimeoutMs = resolveReplyTimeoutMs(args.replyTimeoutMs);
     let reply = typeof replyTimeoutMs === "number" ? await Promise.race([
@@ -14210,9 +14712,12 @@ async function resumeSlackTurn(args) {
     await status.stop();
     const footer = buildSlackReplyFooter({
       conversationId: args.replyContext?.correlation?.conversationId ?? lockKey,
-      durationMs: reply.diagnostics.durationMs,
+      durationMs: typeof priorCheckpoint?.cumulativeDurationMs === "number" || typeof reply.diagnostics.durationMs === "number" ? (priorCheckpoint?.cumulativeDurationMs ?? 0) + (reply.diagnostics.durationMs ?? 0) : void 0,
       thinkingLevel: reply.diagnostics.thinkingLevel,
-      usage: reply.diagnostics.usage
+      usage: addAgentTurnUsage(
+        priorCheckpoint?.cumulativeUsage,
+        reply.diagnostics.usage
+      ) ?? reply.diagnostics.usage
     });
     await postSlackApiReplyPosts({
       channelId: args.channelId,
@@ -15063,6 +15568,8 @@ async function resumeCheckpointedOAuthTurn(stored) {
         fullName: userMessage.author.fullName
       },
       correlation: {
+        conversationId: stored.resumeConversationId,
+        turnId: resolvedSessionId,
         channelId: stored.channelId,
         threadTs: stored.threadTs,
         requesterId: userMessage.author.userId
@@ -17563,7 +18070,51 @@ function maybeUpdateAssistantTitle(args) {
   })();
 }
 
+// src/chat/services/provider-default-config.ts
+var GITHUB_REPO_PART = String.raw`[A-Za-z0-9_.-]*[A-Za-z0-9_-]`;
+var GITHUB_REPO_RE = new RegExp(
+  String.raw`^\s*(?:set|use)\s+(?:the\s+)?default\s+(?:github\s+)?repo(?:sitory)?\s+(?:to|as)\s+(${GITHUB_REPO_PART}/${GITHUB_REPO_PART})(?:\s+for\s+this\s+channel)?[.!?]?\s*$`,
+  "i"
+);
+async function maybeApplyProviderDefaultConfigRequest(args) {
+  const match = GITHUB_REPO_RE.exec(args.text);
+  const repo = match?.[1];
+  if (!repo || !args.channelConfiguration) {
+    return null;
+  }
+  await args.channelConfiguration.set({
+    key: "github.repo",
+    value: repo,
+    updatedBy: args.requesterId,
+    source: "provider-default-config"
+  });
+  return {
+    text: `Default GitHub repo set to \`${repo}\`.`
+  };
+}
+
 // src/chat/runtime/reply-executor.ts
+function collectCanvasUrls(artifacts) {
+  return new Set(
+    [
+      artifacts.lastCanvasUrl,
+      ...artifacts.recentCanvases?.map((canvas) => canvas.url) ?? []
+    ].filter((url) => typeof url === "string" && url !== "")
+  );
+}
+function getCurrentTurnCanvasUrl(args) {
+  const previousUrls = collectCanvasUrls(args.before);
+  const latestUrls = collectCanvasUrls(args.after);
+  for (const url of latestUrls) {
+    if (!previousUrls.has(url)) {
+      return url;
+    }
+  }
+  return void 0;
+}
+function buildCanvasRecoveryReply(canvasUrl) {
+  return `I created the canvas, but the turn was interrupted before I could finish the thread reply: ${canvasUrl}`;
+}
 function createReplyToThread(deps) {
   return async function replyToThread(thread, message, options = {}) {
     if (message.author.isMe) {
@@ -17632,9 +18183,17 @@ function createReplyToThread(deps) {
         const postTurnContinuationNotice = async () => {
           try {
             await beforeFirstResponsePost();
-            await thread.post(
-              buildSlackOutputMessage(buildTurnContinuationResponse())
-            );
+            const notice = buildSlackTurnContinuationNotice({ conversationId });
+            const shouldUseSlackFooter = Boolean(notice.blocks?.length) && Boolean(channelId && threadTs) && thread.adapter?.name === "slack";
+            if (shouldUseSlackFooter && channelId && threadTs) {
+              await postSlackMessage({
+                channelId,
+                threadTs,
+                ...notice
+              });
+              return;
+            }
+            await thread.post(buildSlackOutputMessage(notice.text));
           } catch (error) {
             logException(
               error,
@@ -17708,6 +18267,40 @@ function createReplyToThread(deps) {
             return;
           }
         }
+        const configReply = await maybeApplyProviderDefaultConfigRequest({
+          channelConfiguration: preparedState.channelConfiguration,
+          requesterId: message.author.userId,
+          text: userText
+        });
+        if (configReply) {
+          await beforeFirstResponsePost();
+          await thread.post(buildSlackOutputMessage(configReply.text));
+          markConversationMessage(
+            preparedState.conversation,
+            preparedState.userMessageId,
+            {
+              replied: true,
+              skippedReason: void 0
+            }
+          );
+          upsertConversationMessage(preparedState.conversation, {
+            id: generateConversationId("assistant"),
+            role: "assistant",
+            text: normalizeConversationText(configReply.text),
+            createdAtMs: Date.now(),
+            author: {
+              userName: botConfig.userName,
+              isBot: true
+            },
+            meta: {
+              replied: true
+            }
+          });
+          await persistThreadState(thread, {
+            conversation: preparedState.conversation
+          });
+          return;
+        }
         startActiveTurn({
           conversation: preparedState.conversation,
           nextTurnId: turnId,
@@ -17789,6 +18382,7 @@ function createReplyToThread(deps) {
         });
         let persistedAtLeastOnce = false;
         let shouldPersistFailureState = true;
+        let latestArtifacts = preparedState.artifacts;
         try {
           const toolChannelId = preparedState.artifacts.assistantContextChannelId ?? channelId;
           let reply = await deps.services.generateAssistantReply(userText, {
@@ -17828,6 +18422,7 @@ function createReplyToThread(deps) {
               });
             },
             onArtifactStateUpdated: async (artifacts) => {
+              latestArtifacts = artifacts;
               await persistThreadState(thread, { artifacts });
             },
             onAuthPending: async (pendingAuth) => {
@@ -18045,6 +18640,60 @@ function createReplyToThread(deps) {
             }
           }
           shouldPersistFailureState = true;
+          const createdCanvasUrl = getCurrentTurnCanvasUrl({
+            before: preparedState.artifacts,
+            after: latestArtifacts
+          });
+          if (createdCanvasUrl) {
+            logException(
+              error,
+              "agent_turn_failed_after_canvas_created",
+              turnTraceContext,
+              {
+                ...messageTs ? { "messaging.message.id": messageTs } : {},
+                "app.slack.canvas.has_url": true
+              },
+              "Agent turn failed after creating a Slack canvas"
+            );
+            const recoveryText = buildCanvasRecoveryReply(createdCanvasUrl);
+            await postThreadReply(
+              buildSlackOutputMessage(recoveryText),
+              "thread_reply"
+            );
+            markConversationMessage(
+              preparedState.conversation,
+              preparedState.userMessageId,
+              {
+                replied: true,
+                skippedReason: void 0
+              }
+            );
+            upsertConversationMessage(preparedState.conversation, {
+              id: generateConversationId("assistant"),
+              role: "assistant",
+              text: normalizeConversationText(recoveryText),
+              createdAtMs: Date.now(),
+              author: {
+                userName: botConfig.userName,
+                isBot: true
+              },
+              meta: {
+                replied: true
+              }
+            });
+            markTurnCompleted({
+              conversation: preparedState.conversation,
+              nowMs: Date.now(),
+              updateConversationStats
+            });
+            await persistThreadState(thread, {
+              artifacts: latestArtifacts,
+              conversation: preparedState.conversation
+            });
+            persistedAtLeastOnce = true;
+            shouldPersistFailureState = false;
+            return;
+          }
           throw error;
         } finally {
           if (!persistedAtLeastOnce && shouldPersistFailureState) {
@@ -19185,15 +19834,15 @@ async function defaultWaitUntil() {
     };
   }
 }
-async function resolveBuildPluginPackages() {
+async function resolveBuildPluginConfig() {
   try {
     const mod = await import("#junior/config");
-    return mod.pluginPackages;
+    return mod.plugins;
   } catch {
     const env = process.env.JUNIOR_PLUGIN_PACKAGES;
     if (env) {
       try {
-        return JSON.parse(env);
+        return { packages: JSON.parse(env) };
       } catch {
       }
     }
@@ -19201,9 +19850,9 @@ async function resolveBuildPluginPackages() {
   }
 }
 async function createApp(options) {
-  setPluginPackages(
-    options?.pluginPackages ?? await resolveBuildPluginPackages()
-  );
+  const pluginConfig = options?.plugins ?? await resolveBuildPluginConfig();
+  setPluginPackages(pluginConfig?.packages);
+  setPluginConfig(pluginConfig);
   setConfigDefaults(options?.configDefaults);
   const waitUntil = options?.waitUntil ?? await defaultWaitUntil();
   const app = new Hono();