@sentry/junior 0.61.0 → 0.63.0

package/dist/app.js

@@ -1,18 +1,28 @@
 import {
   GET,
+  JUNIOR_PERSONALITY,
+  TURN_CONTEXT_TAG,
   abandonAgentTurnSessionRecord,
   buildSentryConversationUrl,
+  buildSlackOutputMessage,
+  buildSystemPrompt,
+  buildTurnContextPrompt,
   commitMessages,
+  escapeXml,
   failAgentTurnSessionRecord,
   getAgentTurnSessionRecord,
+  getInterruptionMarker,
   loadConnectedMcpProviders,
   loadProjection,
+  normalizeSlackStatusText,
   recordAgentTurnSessionSummary,
   recordAuthorizationCompleted,
   recordAuthorizationRequested,
   recordMcpProviderConnected,
+  splitSlackReplyText,
+  truncateStatusText,
   upsertAgentTurnSessionRecord
-} from "./chunk-I4FDGMFI.js";
+} from "./chunk-ITZ2F7UE.js";
 import {
   discoverSkills,
   findSkillByName,
@@ -20,25 +30,23 @@ import {
   parseSkillInvocation
 } from "./chunk-ITOW4DED.js";
 import {
-  SANDBOX_DATA_ROOT,
-  SANDBOX_SKILLS_ROOT,
-  SANDBOX_WORKSPACE_ROOT,
   buildNonInteractiveShellScript,
   createSandboxInstance,
   getRuntimeDependencyProfileHash,
   getVercelSandboxCredentials,
   isSnapshotMissingError,
   resolveRuntimeDependencySnapshot,
-  runNonInteractiveCommand,
-  sandboxSkillDir,
-  sandboxSkillFile
-} from "./chunk-QDGD5WVN.js";
+  runNonInteractiveCommand
+} from "./chunk-LRVKJAR2.js";
 import {
   ACTIVE_LOCK_TTL_MS,
   GEN_AI_PROVIDER_NAME,
   GEN_AI_SERVER_ADDRESS,
   GEN_AI_SERVER_PORT,
   MISSING_GATEWAY_CREDENTIALS_ERROR,
+  SANDBOX_DATA_ROOT,
+  SANDBOX_SKILLS_ROOT,
+  SANDBOX_WORKSPACE_ROOT,
   botConfig,
   completeObject,
   completeText,
@@ -55,12 +63,14 @@ import {
   resolveGatewayModel,
   resolveSlackChannelIdFromMessage,
   resolveSlackChannelIdFromThreadId,
+  sandboxSkillDir,
+  sandboxSkillFile,
   toGenAiMessageMetadata,
   toGenAiMessagesTraceAttributes,
   toGenAiPayloadMetadata,
   toGenAiPayloadTraceAttributes,
   toGenAiTextMetadata
-} from "./chunk-FKEKRBUB.js";
+} from "./chunk-PEF6UXTY.js";
 import {
   CredentialUnavailableError,
   buildOAuthTokenRequest,
@@ -105,9 +115,7 @@ import {
 } from "./chunk-Z3YD6NHK.js";
 import {
   homeDir,
-  listReferenceFiles,
-  soulPathCandidates,
-  worldPathCandidates
+  listReferenceFiles
 } from "./chunk-5LUISFEY.js";
 import "./chunk-2KG3PWR4.js";
 
@@ -279,6 +287,16 @@ var AgentPluginHookDeniedError = class extends Error {
 var agentPlugins = [];
 var AGENT_PLUGIN_NAME_RE = /^[a-z][a-z0-9-]*$/;
 var AGENT_PLUGIN_TOOL_NAME_RE = /^[a-z][A-Za-z0-9]*$/;
+var AGENT_PLUGIN_ROUTE_METHODS = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS",
+  "ALL"
+]);
 function validateLegacyStatePrefixes(plugin) {
   const prefixes = plugin.pluginConfig?.legacyStatePrefixes;
   if (prefixes === void 0) {
@@ -368,6 +386,128 @@ function getAgentPluginTools(context) {
   }
   return tools;
 }
+function routeMethods(route, pluginName) {
+  const methods = Array.isArray(route.method) ? route.method : [route.method ?? "ALL"];
+  if (methods.length === 0) {
+    throw new Error(
+      `Trusted plugin route "${route.path}" from plugin "${pluginName}" must declare at least one method`
+    );
+  }
+  for (const method of methods) {
+    if (!AGENT_PLUGIN_ROUTE_METHODS.has(method)) {
+      throw new Error(
+        `Trusted plugin route "${route.path}" from plugin "${pluginName}" has invalid method "${String(method)}"`
+      );
+    }
+  }
+  if (methods.includes("ALL") && methods.length > 1) {
+    throw new Error(
+      `Trusted plugin route "${route.path}" from plugin "${pluginName}" must not combine ALL with explicit methods`
+    );
+  }
+  return methods;
+}
+function getAgentPluginRoutes() {
+  const routes = [];
+  const seen = /* @__PURE__ */ new Set();
+  const methodsByPath = /* @__PURE__ */ new Map();
+  for (const plugin of getAgentPlugins()) {
+    const hook = plugin.hooks?.routes;
+    if (!hook) {
+      continue;
+    }
+    const log = createAgentPluginLogger(plugin.name);
+    const pluginRoutes = hook({
+      plugin: { name: plugin.name },
+      log
+    });
+    if (!Array.isArray(pluginRoutes)) {
+      throw new Error(
+        `Trusted plugin routes hook from plugin "${plugin.name}" must return an array`
+      );
+    }
+    for (const route of pluginRoutes) {
+      if (!isRecord2(route)) {
+        throw new Error(
+          `Trusted plugin route from plugin "${plugin.name}" must be an object`
+        );
+      }
+      if (typeof route.path !== "string" || !route.path.startsWith("/")) {
+        throw new Error(
+          `Trusted plugin route "${route.path}" from plugin "${plugin.name}" must start with /`
+        );
+      }
+      if (typeof route.handler !== "function") {
+        throw new Error(
+          `Trusted plugin route "${route.path}" from plugin "${plugin.name}" must provide a handler`
+        );
+      }
+      const methods = routeMethods(route, plugin.name);
+      const pathMethods = methodsByPath.get(route.path) ?? /* @__PURE__ */ new Set();
+      if (pathMethods.has("ALL") || methods.includes("ALL") && pathMethods.size > 0) {
+        throw new Error(
+          `Trusted plugin route "${route.path}" conflicts with an ALL route for the same path`
+        );
+      }
+      for (const method of methods) {
+        const key = `${method}:${route.path}`;
+        if (seen.has(key)) {
+          throw new Error(
+            `Duplicate trusted plugin route "${method} ${route.path}"`
+          );
+        }
+        seen.add(key);
+        pathMethods.add(method);
+      }
+      methodsByPath.set(route.path, pathMethods);
+      routes.push({
+        ...route,
+        pluginName: plugin.name
+      });
+    }
+  }
+  return routes;
+}
+function trustedSlackConversationUrl(pluginName, link) {
+  const url = typeof link?.url === "string" ? link.url.trim() : "";
+  if (!url) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch (error) {
+    throw new Error(
+      `Trusted plugin "${pluginName}" slackConversationLink must return an absolute http(s) URL`,
+      { cause: error }
+    );
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(
+      `Trusted plugin "${pluginName}" slackConversationLink must return an absolute http(s) URL`
+    );
+  }
+  return parsed.toString();
+}
+function getAgentPluginSlackConversationLink(conversationId) {
+  for (const plugin of getAgentPlugins()) {
+    const hook = plugin.hooks?.slackConversationLink;
+    if (!hook) {
+      continue;
+    }
+    const log = createAgentPluginLogger(plugin.name);
+    const link = hook({
+      plugin: { name: plugin.name },
+      log,
+      conversationId
+    });
+    const url = trustedSlackConversationUrl(plugin.name, link);
+    if (url) {
+      return { url };
+    }
+  }
+  return void 0;
+}
 function isRecord2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -500,747 +640,6 @@ function createAgentPluginHookRunner(input = {}) {
 import { Agent as Agent2 } from "@earendil-works/pi-agent-core";
 import { THREAD_STATE_TTL_MS as THREAD_STATE_TTL_MS3 } from "chat";
 
-// src/chat/prompt.ts
-import fs from "fs";
-import path from "path";
-
-// src/chat/turn-context-tag.ts
-var TURN_CONTEXT_TAG = "runtime-turn-context";
-
-// 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) {
-  const trimmed = text.trim();
-  if (!trimmed) {
-    return "";
-  }
-  if (trimmed.length <= SLACK_STATUS_MAX_LENGTH) {
-    return trimmed;
-  }
-  return `${trimmed.slice(0, SLACK_STATUS_MAX_LENGTH - 3).trimEnd()}...`;
-}
-
-// src/chat/slack/mrkdwn.ts
-function ensureBlockSpacing(text) {
-  const codeBlockPattern = /^```/;
-  const listItemPattern = /^[-*•]\s|^\d+\.\s/;
-  const lines = text.split("\n");
-  const result = [];
-  let inCodeBlock = false;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const isCodeFence = codeBlockPattern.test(line.trimStart());
-    if (isCodeFence) {
-      if (!inCodeBlock) {
-        const prev2 = result.length > 0 ? result[result.length - 1] : void 0;
-        if (prev2 !== void 0 && prev2.trim() !== "") {
-          result.push("");
-        }
-      }
-      inCodeBlock = !inCodeBlock;
-      result.push(line);
-      continue;
-    }
-    if (inCodeBlock) {
-      result.push(line);
-      continue;
-    }
-    const prev = result.length > 0 ? result[result.length - 1] : void 0;
-    if (prev !== void 0 && prev.trim() !== "" && line.trim() !== "" && !(listItemPattern.test(prev.trimStart()) && listItemPattern.test(line.trimStart()))) {
-      result.push("");
-    }
-    result.push(line);
-  }
-  return result.join("\n");
-}
-function renderSlackMrkdwn(text) {
-  let normalized = text.replace(/\r\n?/g, "\n").replace(/[ \t]+$/gm, "");
-  normalized = ensureBlockSpacing(normalized);
-  return normalized.replace(/\n{3,}/g, "\n\n").trim();
-}
-function normalizeSlackStatusText(text) {
-  const trimmed = text.trim();
-  if (!trimmed) {
-    return "";
-  }
-  return truncateStatusText(trimmed.replace(/(?:\.\s*)+$/, "").trim());
-}
-
-// src/chat/slack/output.ts
-var MAX_INLINE_CHARS = 2200;
-var MAX_INLINE_LINES = 45;
-var CONTINUED_MARKER = "\n\n[Continued below]";
-function countSlackLines(text) {
-  if (!text) {
-    return 0;
-  }
-  return text.split("\n").length;
-}
-function fitsInlineBudget(text, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
-  return text.length <= maxChars && countSlackLines(text) <= maxLines;
-}
-function findSplitIndex(text, maxChars) {
-  if (text.length <= maxChars) {
-    return text.length;
-  }
-  const bounded = text.slice(0, maxChars);
-  const newlineIndex = bounded.lastIndexOf("\n");
-  if (newlineIndex > 0) {
-    return newlineIndex;
-  }
-  const spaceIndex = bounded.lastIndexOf(" ");
-  if (spaceIndex > 0) {
-    return spaceIndex;
-  }
-  return maxChars;
-}
-function splitByLineBudget(text, maxLines) {
-  if (maxLines <= 0) {
-    return "";
-  }
-  const lines = text.split("\n");
-  if (lines.length <= maxLines) {
-    return text;
-  }
-  return lines.slice(0, maxLines).join("\n");
-}
-function reserveInlineBudgetForSuffix(suffix, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
-  return {
-    maxChars: Math.max(1, maxChars - suffix.length),
-    maxLines: Math.max(1, maxLines - Math.max(0, countSlackLines(suffix) - 1))
-  };
-}
-function forceSplitBudget(text, budget) {
-  const lineCount = countSlackLines(text);
-  return {
-    maxChars: text.length <= budget.maxChars ? Math.max(1, text.length - 1) : budget.maxChars,
-    maxLines: lineCount <= budget.maxLines ? Math.max(1, lineCount - 1) : budget.maxLines
-  };
-}
-function getFenceContinuation(text) {
-  let open;
-  for (const line of text.split("\n")) {
-    const trimmed = line.trimStart();
-    const openerMatch = trimmed.match(/^(`{3,}|~{3,})(.*)$/);
-    if (!openerMatch) {
-      continue;
-    }
-    if (!open) {
-      open = {
-        fence: openerMatch[1],
-        openerLine: trimmed
-      };
-      continue;
-    }
-    if (new RegExp(`^${open.fence}\\s*$`).test(trimmed)) {
-      open = void 0;
-    }
-  }
-  if (!open) {
-    return null;
-  }
-  return {
-    closeSuffix: text.endsWith("\n") ? open.fence : `
-${open.fence}`,
-    reopenPrefix: `${open.openerLine}
-`
-  };
-}
-function appendSlackSuffix(text, marker) {
-  const carryover = getFenceContinuation(text);
-  return `${text}${carryover?.closeSuffix ?? ""}${marker}`;
-}
-function stripTrailingContinuationMarker(text) {
-  return text.endsWith(CONTINUED_MARKER) ? text.slice(0, -CONTINUED_MARKER.length) : text;
-}
-function takeSlackContinuationChunk(text, budget) {
-  let { prefix, rest } = takeSlackInlinePrefix(text, budget);
-  if (!rest) {
-    ({ prefix, rest } = takeSlackInlinePrefix(
-      text,
-      forceSplitBudget(text, budget)
-    ));
-  }
-  let carryover = rest ? getFenceContinuation(prefix) : null;
-  if (!carryover) {
-    return { prefix, rest };
-  }
-  const carryoverBudget = reserveInlineBudgetForSuffix(
-    `${carryover.closeSuffix}${CONTINUED_MARKER}`
-  );
-  ({ prefix, rest } = takeSlackInlinePrefix(text, carryoverBudget));
-  if (!rest) {
-    ({ prefix, rest } = takeSlackInlinePrefix(
-      text,
-      forceSplitBudget(text, carryoverBudget)
-    ));
-  }
-  carryover = rest ? getFenceContinuation(prefix) : null;
-  if (!carryover) {
-    return { prefix, rest };
-  }
-  return {
-    prefix,
-    rest: `${carryover.reopenPrefix}${rest}`
-  };
-}
-function takeSlackContinuationPrefix(text, options) {
-  const budget = {
-    maxChars: options?.maxChars ?? getSlackContinuationBudget().maxChars,
-    maxLines: options?.maxLines ?? getSlackContinuationBudget().maxLines
-  };
-  const { prefix, rest } = (() => {
-    if (options?.forceSplit) {
-      return takeSlackContinuationChunk(text, budget);
-    }
-    const initial = takeSlackInlinePrefix(text, budget);
-    return initial.rest ? takeSlackContinuationChunk(text, budget) : initial;
-  })();
-  return {
-    prefix,
-    renderedPrefix: rest ? appendSlackSuffix(prefix, CONTINUED_MARKER) : prefix,
-    rest
-  };
-}
-function takeSlackInlinePrefix(text, options) {
-  const maxChars = options?.maxChars ?? MAX_INLINE_CHARS;
-  const maxLines = options?.maxLines ?? MAX_INLINE_LINES;
-  const normalized = text.replace(/\r\n?/g, "\n");
-  if (!normalized) {
-    return { prefix: "", rest: "" };
-  }
-  if (fitsInlineBudget(normalized, maxChars, maxLines)) {
-    return { prefix: normalized, rest: "" };
-  }
-  const lineBounded = splitByLineBudget(normalized, maxLines);
-  const cutIndex = findSplitIndex(lineBounded, maxChars);
-  const prefix = lineBounded.slice(0, cutIndex).trimEnd();
-  if (prefix) {
-    return {
-      prefix,
-      rest: normalized.slice(prefix.length).trimStart()
-    };
-  }
-  const hardPrefix = normalized.slice(0, Math.max(1, maxChars)).trimEnd();
-  return {
-    prefix: hardPrefix || normalized.slice(0, Math.max(1, maxChars)),
-    rest: normalized.slice(hardPrefix.length || Math.max(1, maxChars)).trimStart()
-  };
-}
-function splitSlackReplyText(text, options) {
-  const normalized = renderSlackMrkdwn(text);
-  if (!normalized) {
-    return [];
-  }
-  const chunks = [];
-  const continuationBudget = reserveInlineBudgetForSuffix(CONTINUED_MARKER);
-  let remaining = normalized;
-  while (remaining) {
-    const fitsFinalChunk = options?.interrupted ? fitsInlineBudget(appendSlackSuffix(remaining, getInterruptionMarker())) : fitsInlineBudget(remaining);
-    if (fitsFinalChunk) {
-      chunks.push(
-        options?.interrupted ? appendSlackSuffix(remaining, getInterruptionMarker()) : remaining
-      );
-      break;
-    }
-    const { renderedPrefix, rest } = takeSlackContinuationPrefix(remaining, {
-      ...continuationBudget,
-      forceSplit: true
-    });
-    chunks.push(renderedPrefix);
-    remaining = rest;
-  }
-  if (chunks.length === 2) {
-    chunks[0] = stripTrailingContinuationMarker(chunks[0] ?? "");
-  }
-  return chunks;
-}
-function getSlackContinuationBudget() {
-  return reserveInlineBudgetForSuffix(CONTINUED_MARKER);
-}
-function buildSlackOutputMessage(text, files) {
-  const normalized = renderSlackMrkdwn(text);
-  const fileCount = files?.length ?? 0;
-  if (!normalized) {
-    if (fileCount > 0) {
-      return {
-        raw: "",
-        files
-      };
-    }
-    throw new Error(
-      `Slack output normalized to empty content: original_length=${text.length} parsed_length=${normalized.length}`
-    );
-  }
-  return {
-    markdown: normalized,
-    files
-  };
-}
-var slackOutputPolicy = {
-  maxInlineChars: MAX_INLINE_CHARS,
-  maxInlineLines: MAX_INLINE_LINES
-};
-
-// src/chat/xml.ts
-function escapeXml(value) {
-  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
-}
-
-// src/chat/prompt.ts
-var DEFAULT_SOUL = "You are Junior, a practical and concise assistant.";
-function getLoggedMarkdownFiles() {
-  const globalState = globalThis;
-  globalState.__juniorLoggedMarkdownFiles ??= /* @__PURE__ */ new Set();
-  return globalState.__juniorLoggedMarkdownFiles;
-}
-function loadOptionalMarkdownFile(candidates, fileName) {
-  for (const resolved of candidates) {
-    try {
-      const raw = fs.readFileSync(resolved, "utf8").trim();
-      if (raw.length > 0) {
-        const loggedMarkdownFiles = getLoggedMarkdownFiles();
-        const logKey = `${fileName}:${resolved}`;
-        if (!loggedMarkdownFiles.has(logKey)) {
-          loggedMarkdownFiles.add(logKey);
-          logInfo(
-            `${fileName.toLowerCase()}_loaded`,
-            {},
-            {
-              "file.path": resolved
-            },
-            `Loaded ${fileName}`
-          );
-        }
-        return raw;
-      }
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-function loadSoul() {
-  const soul = loadOptionalMarkdownFile(soulPathCandidates(), "SOUL.md");
-  if (soul) {
-    return soul;
-  }
-  logWarn(
-    "soul_load_fallback",
-    {},
-    {
-      "app.file.candidates": soulPathCandidates()
-    },
-    "SOUL.md not found; using built-in default personality"
-  );
-  return DEFAULT_SOUL;
-}
-function loadWorld() {
-  return loadOptionalMarkdownFile(worldPathCandidates(), "WORLD.md");
-}
-var JUNIOR_PERSONALITY = (() => {
-  try {
-    return loadSoul();
-  } catch (error) {
-    logWarn(
-      "soul_load_failed",
-      {},
-      {
-        "exception.message": error instanceof Error ? error.message : String(error)
-      },
-      "Failed to load SOUL.md; using built-in default personality"
-    );
-    return DEFAULT_SOUL;
-  }
-})();
-var JUNIOR_WORLD = (() => {
-  try {
-    return loadWorld();
-  } catch (error) {
-    logWarn(
-      "world_load_failed",
-      {},
-      {
-        "exception.message": error instanceof Error ? error.message : String(error)
-      },
-      "Failed to load WORLD.md; omitting world prompt context"
-    );
-    return null;
-  }
-})();
-function workspaceSkillDir(skillName) {
-  return sandboxSkillDir(skillName);
-}
-function formatConfigurationValue(value) {
-  if (typeof value === "string") {
-    return escapeXml(value);
-  }
-  try {
-    return escapeXml(JSON.stringify(value));
-  } catch {
-    return escapeXml(String(value));
-  }
-}
-function renderRequesterBlock(fields) {
-  const lines = Object.entries(fields).filter(([, value]) => Boolean(value)).map(([key, value]) => `- ${key}: ${escapeXml(value)}`);
-  if (lines.length === 0) {
-    return null;
-  }
-  return ["<requester>", ...lines, "</requester>"];
-}
-function renderTag(tag, lines) {
-  return [`<${tag}>`, ...lines, `</${tag}>`];
-}
-function renderTagBlock(tag, content) {
-  return [`<${tag}>`, content, `</${tag}>`].join("\n");
-}
-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>`);
-  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 = [];
-  if (autoSelectable.length > 0) {
-    const available = [
-      "<available-skills>",
-      "Scan before answering. Load the most specific matching skill; do not answer from memory when a skill fits. A request that names a skill, plugin, provider, or account matching a skill name is a skill match. 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));
-    }
-    userCallable.push("</user-callable-skills>");
-    sections.push(userCallable.join("\n"));
-  }
-  return sections.length > 0 ? sections.join("\n") : null;
-}
-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`. Put provider fields inside `arguments`."
-  ];
-  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 formatToolGuidanceForPrompt(tools) {
-  const guidedTools = tools.filter(
-    (tool2) => Boolean(tool2.promptSnippet?.trim()) || (tool2.promptGuidelines?.length ?? 0) > 0
-  );
-  if (guidedTools.length === 0) {
-    return null;
-  }
-  const lines = [];
-  for (const tool2 of guidedTools) {
-    lines.push(`  <tool name="${escapeXml(tool2.name)}">`);
-    if (tool2.promptSnippet?.trim()) {
-      lines.push(`    - ${escapeXml(tool2.promptSnippet.trim())}`);
-    }
-    if (tool2.promptGuidelines && tool2.promptGuidelines.length > 0) {
-      for (const guideline of tool2.promptGuidelines) {
-        lines.push(`    - ${escapeXml(guideline)}`);
-      }
-    }
-    lines.push("  </tool>");
-  }
-  return lines.join("\n");
-}
-function formatReferenceFilesLines() {
-  const files = listReferenceFiles();
-  if (files.length === 0) {
-    return null;
-  }
-  return files.map((filePath) => {
-    const name = path.basename(filePath);
-    return `- ${escapeXml(name)} (${escapeXml(`${SANDBOX_DATA_ROOT}/${name}`)})`;
-  });
-}
-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)
-  );
-  if (keys.length === 0) return null;
-  return keys.map(
-    (key) => `- ${escapeXml(key)}: ${formatConfigurationValue(configuration?.[key])}`
-  );
-}
-var HEADER = "You are a Slack-based helper assistant. Follow the personality block for voice and tone in every reply. The behavior and output blocks define platform mechanics and override personality only when those mechanics conflict.";
-var TURN_CONTEXT_HEADER = "Runtime context for this request. Treat these blocks as trusted runtime facts; the static system prompt remains authoritative.";
-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.",
-  "- Resolve provider action targets before calls: explicit target wins; ambient `<configuration>` fills omitted targets. Treat non-target links/references as context.",
-  "- 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 = [
-  "- 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 returned by that tool result."
-];
-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.",
-  "- 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.",
-  "- 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-markdown" max_inline_chars="${slackOutputPolicy.maxInlineChars}" max_inline_lines="${slackOutputPolicy.maxInlineLines}">`;
-  return [
-    openTag,
-    "- Start with the answer or result, not internal process narration.",
-    "- Use Slack-flavored Markdown: **bold** section labels, `code`, [text](url) links, bullet lists, and fenced code blocks. No hash-prefixed headings and no tables. When the answer primarily lists several URLs, show each URL bare instead of as a labeled link.",
-    "- 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 buildIdentitySection() {
-  return renderTagBlock(
-    "identity",
-    `Your Slack username is \`${escapeXml(botConfig.userName)}\`.`
-  );
-}
-function buildRuntimeSection(params) {
-  const lines = [
-    params.conversationId ? `- gen_ai.conversation.id: ${escapeXml(params.conversationId)}` : "",
-    params.traceId ? `- trace_id: ${escapeXml(params.traceId)}` : ""
-  ].filter(Boolean);
-  if (lines.length === 0) {
-    return null;
-  }
-  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
-      ])
-    );
-  }
-  const requesterLines = renderRequesterBlock({
-    full_name: params.requester?.fullName,
-    user_name: params.requester?.userName,
-    user_id: params.requester?.userId
-  });
-  if (requesterLines) {
-    blocks.push(requesterLines);
-  }
-  const artifactLines = formatArtifactsLines(params.artifactState);
-  if (artifactLines) {
-    blocks.push(renderTag("artifacts", artifactLines));
-  }
-  const configLines = formatConfigurationLines(params.configuration);
-  if (configLines) {
-    blocks.push(
-      renderTag("configuration", [
-        "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
-      ])
-    );
-  }
-  if (params.invocation) {
-    blocks.push(
-      renderTag("explicit-skill-trigger", [
-        "Treat this skill as selected. Load it unless the tool says it is unavailable.",
-        `/${escapeXml(params.invocation.skillName)}`
-      ])
-    );
-  }
-  const body = blocks.map((block) => block.join("\n")).join("\n\n");
-  if (!body) {
-    return null;
-  }
-  return renderTagBlock("context", body);
-}
-function buildCapabilitiesSection(params) {
-  const blocks = [];
-  const availableSkills = formatAvailableSkillsForPrompt(
-    params.availableSkills,
-    params.invocation
-  );
-  if (availableSkills) {
-    blocks.push(availableSkills);
-  }
-  const activeCatalogs = formatActiveMcpCatalogsForPrompt(
-    params.activeMcpCatalogs
-  );
-  if (activeCatalogs) {
-    blocks.push(renderTagBlock("active-mcp-catalogs", activeCatalogs));
-  }
-  const toolGuidance = formatToolGuidanceForPrompt(params.toolGuidance ?? []);
-  if (toolGuidance) {
-    blocks.push(renderTagBlock("tool-guidance", toolGuidance));
-  }
-  if (blocks.length === 0) {
-    return null;
-  }
-  return renderTagBlock("capabilities", blocks.join("\n\n"));
-}
-var STATIC_SYSTEM_PROMPT = [
-  HEADER,
-  buildIdentitySection(),
-  renderTagBlock("personality", JUNIOR_PERSONALITY.trim()),
-  renderTagBlock("behavior", buildBehaviorSection()),
-  buildOutputSection()
-].join("\n\n");
-function buildSystemPrompt() {
-  return STATIC_SYSTEM_PROMPT;
-}
-function buildTurnContextPrompt(params) {
-  const includeSessionContext = params.includeSessionContext ?? true;
-  if (!includeSessionContext) {
-    return null;
-  }
-  const runtimeSections = [
-    buildCapabilitiesSection({
-      availableSkills: params.availableSkills,
-      activeMcpCatalogs: params.activeMcpCatalogs ?? [],
-      invocation: params.invocation,
-      toolGuidance: params.toolGuidance ?? []
-    }),
-    buildContextSection({
-      requester: params.requester,
-      artifactState: params.artifactState,
-      configuration: params.configuration,
-      invocation: params.invocation
-    }),
-    buildRuntimeSection(params.runtime ?? {})
-  ].filter((section) => Boolean(section));
-  if (runtimeSections.length === 0) {
-    return null;
-  }
-  const sections = [
-    `<${TURN_CONTEXT_TAG}>`,
-    TURN_CONTEXT_HEADER,
-    "The current user instruction appears after this block in the same message.",
-    ...runtimeSections,
-    `</${TURN_CONTEXT_TAG}>`
-  ].filter((section) => Boolean(section));
-  return sections.join("\n\n");
-}
-
 // src/chat/capabilities/catalog.ts
 var cachedCatalog;
 function getCapabilityCatalog() {
@@ -1635,13 +1034,13 @@ async function maybeExecuteJrRpcCustomCommand(command, deps) {
 }
 
 // src/chat/sandbox/skill-sandbox.ts
-import fs2 from "fs/promises";
-import path2 from "path";
+import fs from "fs/promises";
+import path from "path";
 var MAX_SKILL_FILE_BYTES = 256 * 1024;
 var DEFAULT_MAX_SKILL_FILE_CHARS = 2e4;
 var DEFAULT_MAX_SKILL_LIST_ENTRIES = 200;
 function normalizePathForOutput(value) {
-  return value.split(path2.sep).join("/");
+  return value.split(path.sep).join("/");
 }
 function normalizeSkillName(value) {
   return value.trim().toLowerCase();
@@ -1650,12 +1049,12 @@ function resolvePathWithinRoot(root, relativePath) {
   if (!relativePath.trim()) {
     throw new Error("Path must not be empty.");
   }
-  if (path2.isAbsolute(relativePath)) {
+  if (path.isAbsolute(relativePath)) {
     throw new Error("Absolute paths are not allowed.");
   }
-  const resolvedRoot = path2.resolve(root);
-  const resolvedPath = path2.resolve(resolvedRoot, relativePath);
-  if (resolvedPath !== resolvedRoot && !resolvedPath.startsWith(`${resolvedRoot}${path2.sep}`)) {
+  const resolvedRoot = path.resolve(root);
+  const resolvedPath = path.resolve(resolvedRoot, relativePath);
+  if (resolvedPath !== resolvedRoot && !resolvedPath.startsWith(`${resolvedRoot}${path.sep}`)) {
     throw new Error("Path escapes the skill directory.");
   }
   return resolvedPath;
@@ -1735,9 +1134,9 @@ var SkillSandbox = class {
       1,
       Math.min(params.maxEntries ?? DEFAULT_MAX_SKILL_LIST_ENTRIES, 1e3)
     );
-    const root = path2.resolve(skill.skillPath);
+    const root = path.resolve(skill.skillPath);
     const targetDirectory = resolvePathWithinRoot(root, directory);
-    const targetStats = await fs2.stat(targetDirectory);
+    const targetStats = await fs.stat(targetDirectory);
     if (!targetStats.isDirectory()) {
       throw new Error(`Path is not a directory: ${directory}`);
     }
@@ -1746,14 +1145,14 @@ var SkillSandbox = class {
     let truncated = false;
     while (queue.length > 0) {
       const currentDirectory = queue.shift();
-      const children = await fs2.readdir(currentDirectory, {
+      const children = await fs.readdir(currentDirectory, {
         withFileTypes: true
       });
       children.sort((a, b) => a.name.localeCompare(b.name));
       for (const child of children) {
-        const absolutePath = path2.join(currentDirectory, child.name);
+        const absolutePath = path.join(currentDirectory, child.name);
         const relativePath = normalizePathForOutput(
-          path2.relative(root, absolutePath)
+          path.relative(root, absolutePath)
         );
         if (!relativePath || relativePath.startsWith("..")) {
           continue;
@@ -1776,7 +1175,7 @@ var SkillSandbox = class {
       }
     }
     const relativeDirectory = normalizePathForOutput(
-      path2.relative(root, targetDirectory) || "."
+      path.relative(root, targetDirectory) || "."
     );
     return {
       skillName: skill.name,
@@ -1791,9 +1190,9 @@ var SkillSandbox = class {
       1,
       Math.min(params.maxChars ?? DEFAULT_MAX_SKILL_FILE_CHARS, 1e5)
     );
-    const root = path2.resolve(skill.skillPath);
+    const root = path.resolve(skill.skillPath);
     const targetPath = resolvePathWithinRoot(root, params.filePath);
-    const stats = await fs2.stat(targetPath);
+    const stats = await fs.stat(targetPath);
     if (!stats.isFile()) {
       throw new Error(`Path is not a file: ${params.filePath}`);
     }
@@ -1802,11 +1201,11 @@ var SkillSandbox = class {
         `File exceeds ${MAX_SKILL_FILE_BYTES} bytes and cannot be loaded.`
       );
     }
-    const raw = await fs2.readFile(targetPath, "utf8");
+    const raw = await fs.readFile(targetPath, "utf8");
     const truncated = raw.length > maxChars;
     return {
       skillName: skill.name,
-      path: normalizePathForOutput(path2.relative(root, targetPath)),
+      path: normalizePathForOutput(path.relative(root, targetPath)),
       content: truncated ? raw.slice(0, maxChars) : raw,
       truncated
     };
@@ -2544,7 +1943,7 @@ function createBashTool() {
 }
 
 // src/chat/tools/sandbox/file-utils.ts
-import path3 from "path";
+import path2 from "path";
 
 // src/chat/tools/execution/tool-input-error.ts
 var ToolInputError = class extends Error {
@@ -2640,12 +2039,12 @@ function matchesGlob(relativePath, pattern) {
   if (pattern.startsWith("**/") && matchesGlob(relativePath, pattern.slice(3))) {
     return true;
   }
-  return !pattern.includes("/") && matcher.test(path3.posix.basename(relativePath));
+  return !pattern.includes("/") && matcher.test(path2.posix.basename(relativePath));
 }
 function resolveWorkspacePath(input, fallback = ".") {
   const requested = (input ?? "").trim() || fallback;
-  const absolute = requested.startsWith("/") ? requested : path3.posix.join(SANDBOX_WORKSPACE_ROOT, requested);
-  const normalized = path3.posix.normalize(absolute);
+  const absolute = requested.startsWith("/") ? requested : path2.posix.join(SANDBOX_WORKSPACE_ROOT, requested);
+  const normalized = path2.posix.normalize(absolute);
   if (normalized !== SANDBOX_WORKSPACE_ROOT && !normalized.startsWith(`${SANDBOX_WORKSPACE_ROOT}/`)) {
     throw new ToolInputError(
       `Path must stay within ${SANDBOX_WORKSPACE_ROOT}: ${requested}`
@@ -2674,7 +2073,7 @@ async function collectFiles(params) {
       throw error;
     }
     for (const entry of entries) {
-      const fullPath = path3.posix.join(dirPath, entry);
+      const fullPath = path2.posix.join(dirPath, entry);
       let stat2;
       try {
         stat2 = await params.fs.stat(fullPath);
@@ -2692,7 +2091,7 @@ async function collectFiles(params) {
         if (limitReached) return;
         continue;
       }
-      const relativePath = path3.posix.relative(params.root, fullPath);
+      const relativePath = path2.posix.relative(params.root, fullPath);
       if (!params.pattern || matchesGlob(relativePath, params.pattern)) {
         files.push(fullPath);
         if (params.limit && files.length >= params.limit) {
@@ -2717,7 +2116,7 @@ async function collectFiles(params) {
     throw error;
   }
   if (!stat.isDirectory()) {
-    const relativePath = path3.posix.basename(params.root);
+    const relativePath = path2.posix.basename(params.root);
     return {
       files: !params.pattern || matchesGlob(relativePath, params.pattern) ? [params.root] : [],
       limitReached: false,
@@ -2994,7 +2393,7 @@ function createEditFileTool() {
 }
 
 // src/chat/tools/sandbox/find-files.ts
-import path4 from "path";
+import path3 from "path";
 import { Type as Type3 } from "@sinclair/typebox";
 var DEFAULT_FIND_LIMIT = 1e3;
 async function findFiles(params) {
@@ -3016,7 +2415,7 @@ async function findFiles(params) {
     });
   }
   const relativePaths = files.map(
-    (filePath) => path4.posix.relative(root, filePath)
+    (filePath) => path3.posix.relative(root, filePath)
   );
   const bounded = truncateText(
     relativePaths.length > 0 ? relativePaths.join("\n") : "No files found matching pattern"
@@ -3081,7 +2480,7 @@ function createFindFilesTool() {
 }
 
 // src/chat/tools/sandbox/grep.ts
-import path5 from "path";
+import path4 from "path";
 import { Type as Type4 } from "@sinclair/typebox";
 var DEFAULT_GREP_LIMIT = 100;
 var MAX_GREP_LINE_CHARS = 500;
@@ -3153,7 +2552,7 @@ async function grepFiles(params) {
       continue;
     }
     const lines = normalizeToLf(content).split("\n");
-    const relativePath = files.length === 1 && filePath === root ? path5.posix.basename(filePath) : path5.posix.relative(root, filePath);
+    const relativePath = files.length === 1 && filePath === root ? path4.posix.basename(filePath) : path4.posix.relative(root, filePath);
     const matchedLines = [];
     for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
       if (!lineMatches({
@@ -3280,7 +2679,7 @@ function createGrepTool() {
 }
 
 // src/chat/tools/sandbox/attach-file.ts
-import path6 from "path";
+import path5 from "path";
 import { Type as Type5 } from "@sinclair/typebox";
 var MAX_ATTACH_FILE_BYTES = 10 * 1024 * 1024;
 var MIME_BY_EXTENSION = {
@@ -3302,20 +2701,20 @@ function normalizeSandboxPath(inputPath) {
   if (!trimmed) {
     throw new Error("path is required");
   }
-  if (path6.posix.isAbsolute(trimmed)) {
+  if (path5.posix.isAbsolute(trimmed)) {
     return trimmed;
   }
-  return path6.posix.join(SANDBOX_WORKSPACE_ROOT, trimmed);
+  return path5.posix.join(SANDBOX_WORKSPACE_ROOT, trimmed);
 }
 function sanitizeFilename(value, fallbackPath) {
   const candidate = (value ?? "").trim();
   if (candidate) {
-    const base = path6.posix.basename(candidate);
+    const base = path5.posix.basename(candidate);
     if (base && base !== "." && base !== "..") {
       return base;
     }
   }
-  const derived = path6.posix.basename(fallbackPath);
+  const derived = path5.posix.basename(fallbackPath);
   if (derived && derived !== "." && derived !== "..") {
     return derived;
   }
@@ -3326,7 +2725,7 @@ function inferMimeType(filename, explicitMimeType) {
   if (explicit) {
     return explicit;
   }
-  const ext = path6.extname(filename).toLowerCase();
+  const ext = path5.extname(filename).toLowerCase();
   return MIME_BY_EXTENSION[ext] ?? "application/octet-stream";
 }
 async function detectMimeType(sandbox, targetPath) {
@@ -3373,7 +2772,7 @@ function createAttachFileTool(sandbox, hooks = {}) {
       const fileBuffer = await sandbox.readFileToBuffer({ path: targetPath });
       if (!fileBuffer) {
         const generatedFile = hooks.getGeneratedFile?.(
-          path6.posix.basename(targetPath)
+          path5.posix.basename(targetPath)
         );
         if (generatedFile) {
           hooks.onGeneratedFiles?.([generatedFile]);
@@ -3421,7 +2820,7 @@ function createAttachFileTool(sandbox, hooks = {}) {
 }
 
 // src/chat/tools/sandbox/list-dir.ts
-import path7 from "path";
+import path6 from "path";
 import { Type as Type6 } from "@sinclair/typebox";
 var DEFAULT_LIST_LIMIT = 500;
 async function listDir(params) {
@@ -3457,7 +2856,7 @@ async function listDir(params) {
       entryLimitReached = true;
       break;
     }
-    const entryPath = path7.posix.join(dirPath, entry);
+    const entryPath = path6.posix.join(dirPath, entry);
     try {
       const entryStat = await params.fs.stat(entryPath);
       output.push(`${entry}${entryStat.isDirectory() ? "/" : ""}`);
@@ -4116,11 +3515,11 @@ function sliceFileContent(params) {
     } : {}
   };
 }
-function missingFileResult(path10) {
+function missingFileResult(path9) {
   return {
     content: "",
     error: "not_found",
-    path: path10,
+    path: path9,
     success: false
   };
 }
@@ -6585,15 +5984,22 @@ function summarizeMessageText(text) {
   }
   return normalized.length > 1200 ? `${normalized.slice(0, 1200)}...` : normalized;
 }
+function isStructuredThreadContext(context) {
+  return /^<thread-(compactions|transcript)>/.test(context);
+}
+function renderThreadContextForPrompt(context) {
+  if (isStructuredThreadContext(context)) {
+    return context;
+  }
+  return ["<thread-background>", context, "</thread-background>"].join("\n");
+}
 function buildUserTurnText(userInput, conversationContext) {
   const trimmedContext = conversationContext?.trim();
   if (!trimmedContext) {
     return userInput;
   }
   return [
-    "<thread-background>",
-    trimmedContext,
-    "</thread-background>",
+    renderThreadContextForPrompt(trimmedContext),
     "",
     "<current-instruction>",
     userInput,
@@ -7881,7 +7287,7 @@ function createTracedStreamFn(baseOrOptions = streamSimple) {
 }
 
 // src/chat/sandbox/sandbox.ts
-import fs4 from "fs/promises";
+import fs3 from "fs/promises";
 
 // src/chat/oauth-flow.ts
 import { randomBytes } from "crypto";
@@ -8205,8 +7611,8 @@ function sandboxProxyUrl(requesterToken) {
       "Cannot determine base URL for sandbox credential egress (set JUNIOR_BASE_URL or deploy to Vercel)"
     );
   }
-  const path10 = requesterToken ? `${SANDBOX_EGRESS_PROXY_PATH}/${requesterToken}` : SANDBOX_EGRESS_PROXY_PATH;
-  return new URL(path10, baseUrl).toString();
+  const path9 = requesterToken ? `${SANDBOX_EGRESS_PROXY_PATH}/${requesterToken}` : SANDBOX_EGRESS_PROXY_PATH;
+  return new URL(path9, baseUrl).toString();
 }
 function buildSandboxEgressNetworkPolicy(input) {
   const allow = {
@@ -8453,20 +7859,20 @@ import { Sandbox } from "@vercel/sandbox";
 import { createBashTool as createBashTool2 } from "bash-tool";
 
 // src/chat/sandbox/skill-sync.ts
-import fs3 from "fs/promises";
-import path8 from "path";
+import fs2 from "fs/promises";
+import path7 from "path";
 function toPosixRelative(base, absolute) {
-  return path8.relative(base, absolute).split(path8.sep).join("/");
+  return path7.relative(base, absolute).split(path7.sep).join("/");
 }
 async function listFilesRecursive(root) {
   const queue = [root];
   const files = [];
   while (queue.length > 0) {
     const dir = queue.shift();
-    const entries = await fs3.readdir(dir, { withFileTypes: true });
+    const entries = await fs2.readdir(dir, { withFileTypes: true });
     entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
-      const absolute = path8.join(dir, entry.name);
+      const absolute = path7.join(dir, entry.name);
       if (entry.isDirectory()) {
         queue.push(absolute);
       } else if (entry.isFile()) {
@@ -8490,7 +7896,7 @@ async function buildSkillSyncFiles(availableSkills, referenceFiles) {
       }
       filesToWrite.push({
         path: `${sandboxSkillDir(skill.name)}/${relative}`,
-        content: await fs3.readFile(absoluteFile)
+        content: await fs2.readFile(absoluteFile)
       });
     }
     index.skills.push({
@@ -8505,10 +7911,10 @@ async function buildSkillSyncFiles(availableSkills, referenceFiles) {
   });
   if (referenceFiles && referenceFiles.length > 0) {
     for (const absoluteFile of referenceFiles) {
-      const fileName = path8.basename(absoluteFile);
+      const fileName = path7.basename(absoluteFile);
       filesToWrite.push({
         path: `${SANDBOX_DATA_ROOT}/${fileName}`,
-        content: await fs3.readFile(absoluteFile)
+        content: await fs2.readFile(absoluteFile)
       });
     }
   }
@@ -8517,7 +7923,7 @@ async function buildSkillSyncFiles(availableSkills, referenceFiles) {
 function collectDirectories(filesToWrite, workspaceRoot) {
   const directoriesToEnsure = /* @__PURE__ */ new Set();
   for (const file of filesToWrite) {
-    const normalizedPath = path8.posix.normalize(file.path);
+    const normalizedPath = path7.posix.normalize(file.path);
     const parts = normalizedPath.split("/").filter(Boolean);
     let current = "";
     for (let index = 0; index < parts.length - 1; index += 1) {
@@ -8530,19 +7936,19 @@ function collectDirectories(filesToWrite, workspaceRoot) {
   ).sort((a, b) => a.length - b.length);
 }
 function resolveHostSkillPath(availableSkills, sandboxPath) {
-  const normalizedPath = path8.posix.normalize(sandboxPath.trim());
+  const normalizedPath = path7.posix.normalize(sandboxPath.trim());
   for (const skill of availableSkills) {
     const virtualRoot = sandboxSkillDir(skill.name);
     if (normalizedPath !== virtualRoot && !normalizedPath.startsWith(`${virtualRoot}/`)) {
       continue;
     }
-    const relativePath = path8.posix.relative(virtualRoot, normalizedPath);
+    const relativePath = path7.posix.relative(virtualRoot, normalizedPath);
     if (!relativePath || relativePath.startsWith("../")) {
       return null;
     }
-    const hostRoot = path8.resolve(skill.skillPath);
-    const hostPath = path8.resolve(hostRoot, ...relativePath.split("/"));
-    if (hostPath !== hostRoot && !hostPath.startsWith(`${hostRoot}${path8.sep}`)) {
+    const hostRoot = path7.resolve(skill.skillPath);
+    const hostPath = path7.resolve(hostRoot, ...relativePath.split("/"));
+    if (hostPath !== hostRoot && !hostPath.startsWith(`${hostRoot}${path7.sep}`)) {
       return null;
     }
     return hostPath;
@@ -8550,16 +7956,16 @@ function resolveHostSkillPath(availableSkills, sandboxPath) {
   return null;
 }
 function resolveHostDataPath(referenceFiles, sandboxPath) {
-  const normalizedPath = path8.posix.normalize(sandboxPath.trim());
+  const normalizedPath = path7.posix.normalize(sandboxPath.trim());
   if (normalizedPath !== SANDBOX_DATA_ROOT && !normalizedPath.startsWith(`${SANDBOX_DATA_ROOT}/`)) {
     return null;
   }
-  const relativePath = path8.posix.relative(SANDBOX_DATA_ROOT, normalizedPath);
+  const relativePath = path7.posix.relative(SANDBOX_DATA_ROOT, normalizedPath);
   if (!relativePath || relativePath.startsWith("../") || relativePath.includes("/")) {
     return null;
   }
   for (const hostFile of referenceFiles) {
-    if (path8.basename(hostFile) === relativePath) {
+    if (path7.basename(hostFile) === relativePath) {
       return hostFile;
     }
   }
@@ -8619,6 +8025,7 @@ async function syncSkillsToSandbox(params) {
 
 // src/chat/sandbox/session.ts
 var DEFAULT_MAX_OUTPUT_LENGTH = 3e4;
+var DEFAULT_BASH_COMMAND_TIMEOUT_MS = 5 * 60 * 1e3;
 var SANDBOX_RUNTIME = "node22";
 var SANDBOX_RUNTIME_BIN_DIR = `${SANDBOX_WORKSPACE_ROOT}/.junior/bin`;
 var SNAPSHOT_BOOT_RETRY_COUNT = 3;
@@ -8691,6 +8098,16 @@ function getCommandStreamInterruptedResult() {
     stderrTruncated: false
   };
 }
+function getCommandAbortedResult() {
+  return {
+    stdout: "",
+    stderr: "Command aborted because the agent turn was cancelled.",
+    exitCode: 130,
+    stdoutTruncated: false,
+    stderrTruncated: false,
+    aborted: true
+  };
+}
 function createSandboxSessionManager(options) {
   let sandbox = null;
   let sandboxIdHint = options?.sandboxId;
@@ -8946,7 +8363,9 @@ function createSandboxSessionManager(options) {
       "sandbox_hint_discarded_profile_mismatch",
       traceContext,
       {
-        ...options?.sandboxDependencyProfileHash ? { "app.sandbox.previous_profile_hash": options.sandboxDependencyProfileHash } : {},
+        ...options?.sandboxDependencyProfileHash ? {
+          "app.sandbox.previous_profile_hash": options.sandboxDependencyProfileHash
+        } : {},
         ...dependencyProfileHash ? { "app.sandbox.current_profile_hash": dependencyProfileHash } : {}
       },
       "Dependency profile changed; discarding sandbox hint and creating fresh session"
@@ -9114,37 +8533,63 @@ function createSandboxSessionManager(options) {
     return {
       bash: async (input) => {
         let timedOut = false;
+        let aborted = false;
         let timeoutId;
+        let onAbort;
         try {
+          if (input.signal?.aborted) {
+            return getCommandAbortedResult();
+          }
           await refreshNetworkPolicy(sandboxInstance);
+          if (input.signal?.aborted) {
+            return getCommandAbortedResult();
+          }
           const sandboxCommandEnv = await resolveCommandEnv();
+          if (input.signal?.aborted) {
+            return getCommandAbortedResult();
+          }
           const script = buildNonInteractiveShellScript(input.command, {
             env: { ...sandboxCommandEnv, ...input.env ?? {} },
             pathPrefix: `${SANDBOX_RUNTIME_BIN_DIR}:$PATH`
           });
-          const controller = input.timeoutMs && input.timeoutMs > 0 ? new AbortController() : void 0;
-          timeoutId = controller ? setTimeout(() => {
+          const controller = new AbortController();
+          const timeoutMs2 = input.timeoutMs && input.timeoutMs > 0 ? input.timeoutMs : DEFAULT_BASH_COMMAND_TIMEOUT_MS;
+          onAbort = () => {
+            aborted = true;
+            controller.abort(input.signal?.reason);
+          };
+          if (input.signal) {
+            input.signal.addEventListener("abort", onAbort, { once: true });
+            if (input.signal.aborted) {
+              onAbort();
+            }
+          }
+          timeoutId = setTimeout(() => {
             timedOut = true;
             controller.abort();
-          }, input.timeoutMs) : void 0;
+          }, timeoutMs2);
+          timeoutId.unref?.();
           const commandResult2 = await sandboxInstance.runCommand({
             cmd: "bash",
             args: ["-c", script],
             cwd: SANDBOX_WORKSPACE_ROOT,
-            ...controller ? { signal: controller.signal } : {}
+            signal: controller.signal
           });
           return await readCommandOutput(commandResult2);
         } catch (error) {
           if (timedOut) {
             return {
               stdout: "",
-              stderr: `Command timed out after ${input.timeoutMs}ms`,
+              stderr: `Command timed out after ${input.timeoutMs && input.timeoutMs > 0 ? input.timeoutMs : DEFAULT_BASH_COMMAND_TIMEOUT_MS}ms`,
               exitCode: 124,
               stdoutTruncated: false,
               stderrTruncated: false,
               timedOut: true
             };
           }
+          if (aborted || input.signal?.aborted) {
+            return getCommandAbortedResult();
+          }
           if (isSandboxCommandStreamInterruptedError(error)) {
             return getCommandStreamInterruptedResult();
           }
@@ -9153,6 +8598,9 @@ function createSandboxSessionManager(options) {
           if (timeoutId) {
             clearTimeout(timeoutId);
           }
+          if (input.signal && onAbort) {
+            input.signal.removeEventListener("abort", onAbort);
+          }
         }
       },
       readFile: async (input) => await executeReadFile(input, {
@@ -9328,7 +8776,7 @@ function createSandboxExecutor(options) {
       "Sandbox boot requested"
     );
   };
-  const executeBashTool = async (rawInput, command) => {
+  const executeBashTool = async (rawInput, command, signal) => {
     const env = parseEnv(rawInput.env);
     const timeoutMs = positiveInteger(rawInput.timeoutMs);
     logSandboxBootRequest("tool.bash", {
@@ -9346,7 +8794,8 @@ function createSandboxExecutor(options) {
           const response = await executeBash({
             command,
             ...env ? { env } : {},
-            ...timeoutMs ? { timeoutMs } : {}
+            ...timeoutMs ? { timeoutMs } : {},
+            ...signal ? { signal } : {}
           });
           setSpanAttributes({
             "process.exit.code": response.exitCode,
@@ -9397,7 +8846,7 @@ function createSandboxExecutor(options) {
       const hostPath = resolveHostSkillPath(availableSkills, filePath) ?? resolveHostDataPath(referenceFiles, filePath);
       if (hostPath) {
         try {
-          const content = await fs4.readFile(hostPath, "utf8");
+          const content = await fs3.readFile(hostPath, "utf8");
           setSpanAttributes({
             "app.sandbox.path.length": filePath.length,
             "app.sandbox.read.bytes": Buffer.byteLength(content, "utf8"),
@@ -9616,7 +9065,7 @@ function createSandboxExecutor(options) {
           return { result: custom.result };
         }
       }
-      return await executeBashTool(rawInput, bashCommand);
+      return await executeBashTool(rawInput, bashCommand, params.signal);
     }
     try {
       if (params.toolName === "readFile") {
@@ -10455,7 +9904,7 @@ function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor
     parameters: toolDef.inputSchema,
     prepareArguments: toolDef.prepareArguments,
     executionMode: toolDef.executionMode,
-    execute: async (toolCallId, params) => {
+    execute: async (toolCallId, params, signal) => {
       const normalizedToolCallId = typeof toolCallId === "string" && toolCallId.length > 0 ? toolCallId : void 0;
       const toolArgumentsAttribute = serializeToolPayload(params);
       const toolArgumentsMetadata = toGenAiPayloadTraceAttributes(
@@ -10503,9 +9952,11 @@ function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor
             const isSandbox = Boolean(sandboxExecutor?.canExecute(toolName));
             const result = isSandbox ? await sandboxExecutor.execute({
               toolName,
-              input: sandboxInput
+              input: sandboxInput,
+              ...signal ? { signal } : {}
             }) : await toolDef.execute(toolInput, {
-              experimental_context: sandbox
+              experimental_context: sandbox,
+              ...signal ? { signal } : {}
             });
             const normalized = normalizeToolResult(result, isSandbox);
             if (bashCommand && pluginAuthOrchestration) {
@@ -11484,13 +10935,13 @@ function buildClassifierSystemPrompt() {
     "Choose exactly one bucket: none, low, medium, high, or xhigh.",
     "",
     "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 low rarely: only for deterministic one-step answers or transformations with no tools, no current/external facts, no prior thread-context 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 research-heavy work, non-trivial drafting, or explicit requests to be thorough.",
     "Use xhigh for the most complex tasks: code changes, debugging/root-cause analysis, broad refactors, architecture decisions, multi-file implementation, or any task where deep reasoning across multiple systems or files is required.",
     "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.",
+    "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 prior thread context contains a pending task, classify the pending task \u2014 not the affirmation.",
     "",
     "Return JSON only with thinking_level, confidence, and reason.",
     "confidence must be a number from 0 to 1, not a word label."
@@ -11499,12 +10950,17 @@ function buildClassifierSystemPrompt() {
 function buildClassifierPrompt(args) {
   const sections = [];
   if (args.conversationContext) {
-    sections.push(
-      "<thread-background>",
-      args.conversationContext.text,
-      "</thread-background>",
-      ""
-    );
+    const contextText = args.conversationContext.text;
+    if (/^<thread-(compactions|transcript)>/.test(contextText)) {
+      sections.push(contextText, "");
+    } else {
+      sections.push(
+        "<thread-background>",
+        contextText,
+        "</thread-background>",
+        ""
+      );
+    }
   }
   sections.push(
     "<current-instruction>",
@@ -12296,9 +11752,38 @@ function createMcpAuthOrchestration(deps, abortAgent) {
 
 // src/chat/respond.ts
 var PROVIDER_RETRY_DELAYS_MS = [1e3, 2e3];
+var AGENT_ABORT_SETTLE_GRACE_MS = 5e3;
 function sleep3(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function waitForAbortSettlement(promise, timeoutMs) {
+  return new Promise((resolve) => {
+    let done = false;
+    const timeoutId = setTimeout(() => {
+      if (!done) {
+        done = true;
+        resolve(false);
+      }
+    }, timeoutMs);
+    timeoutId.unref?.();
+    promise.then(
+      () => {
+        if (!done) {
+          done = true;
+          clearTimeout(timeoutId);
+          resolve(true);
+        }
+      },
+      () => {
+        if (!done) {
+          done = true;
+          clearTimeout(timeoutId);
+          resolve(true);
+        }
+      }
+    );
+  });
+}
 var startupDiscoveryLogged = false;
 var MAX_ROUTER_ATTACHMENT_PREVIEW_CHARS = 2e3;
 function buildOmittedImageAttachmentNotice(count) {
@@ -12865,8 +12350,7 @@ async function generateAssistantReply(messageText2, context = {}) {
       includeSessionContext,
       toolGuidance,
       runtime: {
-        conversationId: spanContext.conversationId,
-        traceId: getActiveTraceId()
+        conversationId: spanContext.conversationId
       },
       invocation: skillInvocation,
       requester: context.requester,
@@ -13054,8 +12538,20 @@ async function generateAssistantReply(messageText2, context = {}) {
                   },
                   "Agent turn timed out and was aborted"
                 );
-                await run2.catch(() => {
-                });
+                const settled = await waitForAbortSettlement(
+                  run2,
+                  AGENT_ABORT_SETTLE_GRACE_MS
+                );
+                if (!settled) {
+                  logWarn(
+                    "agent_turn_abort_settle_timeout",
+                    {},
+                    {
+                      "app.ai.abort_settle_grace_ms": AGENT_ABORT_SETTLE_GRACE_MS
+                    },
+                    "Timed-out agent run did not settle after abort before resume snapshot"
+                  );
+                }
                 timeoutResumeMessages = [...agent.state.messages];
               }
               if (getPendingAuthPause()) {
@@ -13447,20 +12943,25 @@ function buildConversationContext(conversation, options = {}) {
         "  </compaction>"
       );
     }
-    lines.push("</thread-compactions>", "");
+    lines.push("</thread-compactions>");
   }
-  lines.push("<thread-transcript>");
-  for (const [index, message] of messages.entries()) {
-    const author = escapeXml(message.author?.userName ?? message.role);
-    const ts = new Date(message.createdAtMs).toISOString();
-    const slackTsAttr = message.meta?.slackTs ? ` slack_ts="${escapeXml(message.meta.slackTs)}"` : "";
-    lines.push(
-      `  <message index="${index + 1}" ts="${ts}" role="${message.role}" author="${author}"${slackTsAttr}>`,
-      renderConversationMessageLine(message, conversation),
-      "  </message>"
-    );
+  if (messages.length > 0) {
+    if (lines.length > 0) {
+      lines.push("");
+    }
+    lines.push("<thread-transcript>");
+    for (const [index, message] of messages.entries()) {
+      const author = escapeXml(message.author?.userName ?? message.role);
+      const ts = new Date(message.createdAtMs).toISOString();
+      const slackTsAttr = message.meta?.slackTs ? ` slack_ts="${escapeXml(message.meta.slackTs)}"` : "";
+      lines.push(
+        `  <message index="${index + 1}" ts="${ts}" role="${message.role}" author="${author}"${slackTsAttr}>`,
+        renderConversationMessageLine(message, conversation),
+        "  </message>"
+      );
+    }
+    lines.push("</thread-transcript>");
   }
-  lines.push("</thread-transcript>");
   return lines.join("\n");
 }
 function pruneCompactions(compactions) {
@@ -13700,7 +13201,7 @@ function buildSlackReplyFooter(args) {
       label: "ID",
       value: conversationId
     };
-    const conversationUrl = buildSentryConversationUrl(conversationId);
+    const conversationUrl = getAgentPluginSlackConversationLink(conversationId)?.url ?? buildSentryConversationUrl(conversationId);
     if (conversationUrl) {
       idItem.url = conversationUrl;
     }
@@ -16465,8 +15966,8 @@ async function GET3(request, provider, waitUntil) {
 import { THREAD_STATE_TTL_MS as THREAD_STATE_TTL_MS5 } from "chat";
 
 // src/chat/slack/app-home.ts
-import fs5 from "fs";
-import path9 from "path";
+import fs4 from "fs";
+import path8 from "path";
 var DEFAULT_DESCRIPTION_TEXT = "I help your team investigate, summarize, and act on work in Slack.";
 var MAX_HOME_SKILLS = 6;
 var MAX_SECTION_TEXT_CHARS = 3e3;
@@ -16478,9 +15979,9 @@ function clampSectionText(text) {
   return `${text.slice(0, MAX_SECTION_TEXT_CHARS - 1)}\u2026`;
 }
 function loadDescriptionText() {
-  const descriptionPath = path9.join(homeDir(), "DESCRIPTION.md");
+  const descriptionPath = path8.join(homeDir(), "DESCRIPTION.md");
   try {
-    const raw = fs5.readFileSync(descriptionPath, "utf8").trim();
+    const raw = fs4.readFileSync(descriptionPath, "utf8").trim();
     if (raw.length > 0) {
       return clampSectionText(raw);
     }
@@ -17308,12 +16809,12 @@ function normalizePort(value) {
 function sandboxIdFromPayload(payload) {
   return typeof payload.sandbox_id === "string" ? payload.sandbox_id : void 0;
 }
-function normalizedForwardedPath(path10) {
-  if (!path10.startsWith("/") || path10.startsWith("//") || path10.includes("#") || /[\r\n]/.test(path10)) {
+function normalizedForwardedPath(path9) {
+  if (!path9.startsWith("/") || path9.startsWith("//") || path9.includes("#") || /[\r\n]/.test(path9)) {
     return { ok: false, error: "Invalid forwarded path" };
   }
   try {
-    const url = new URL(path10, "https://sandbox-forwarded.local");
+    const url = new URL(path9, "https://sandbox-forwarded.local");
     return { ok: true, path: `${url.pathname}${url.search}` };
   } catch {
     return { ok: false, error: "Invalid forwarded path" };
@@ -17348,13 +16849,13 @@ function buildUpstreamUrl(request) {
   if (forwardedPort && !port) {
     return { ok: false, error: "Invalid forwarded port" };
   }
-  const path10 = upstreamPath(request);
-  if (!path10.ok) {
-    return { ok: false, error: path10.error };
+  const path9 = upstreamPath(request);
+  if (!path9.ok) {
+    return { ok: false, error: path9.error };
   }
   try {
     const url = new URL(
-      `${scheme}://${host}${port ? `:${port}` : ""}${path10.path}`
+      `${scheme}://${host}${port ? `:${port}` : ""}${path9.path}`
     );
     return { ok: true, url };
   } catch {
@@ -20117,7 +19618,7 @@ function createReplyToThread(deps) {
           if (conversationId && loadedPiMessages.canCompact && piMessages?.length) {
             const compaction = await deps.services.contextCompactor.maybeCompact({
               conversation: preparedState.conversation,
-              conversationContext: preparedState.routingContext ?? preparedState.conversationContext,
+              conversationContext: preparedState.conversationContext,
               conversationId,
               metadata: {
                 threadId,
@@ -20159,7 +19660,7 @@ function createReplyToThread(deps) {
                 fullName: message.author.fullName ?? fallbackIdentity?.fullName,
                 email: fallbackIdentity?.email
               },
-              conversationContext: preparedState.routingContext ?? preparedState.conversationContext,
+              conversationContext: preparedState.conversationContext,
               artifactState: preparedState.artifacts,
               piMessages,
               pendingAuth: preparedState.conversation.processing.pendingAuth,
@@ -20720,8 +20221,7 @@ function createPrepareTurnState(deps) {
       requesterId: args.context.requesterId,
       runId: args.context.runId
     });
-    const conversationContext = buildConversationContext(conversation);
-    const routingContext = buildConversationContext(conversation, {
+    const conversationContext = buildConversationContext(conversation, {
       excludeMessageId: userMessageId
     });
     setSpanAttributes({
@@ -20736,7 +20236,6 @@ function createPrepareTurnState(deps) {
       sandboxId: existingSandboxId,
       sandboxDependencyProfileHash: existingSandboxDependencyProfileHash,
       conversationContext,
-      routingContext,
       userMessageId
     };
   };
@@ -20783,7 +20282,7 @@ function createSlackRuntime(options) {
         conversation: preparedState.conversation
       });
     },
-    getPreparedConversationContext: (preparedState) => preparedState.routingContext ?? preparedState.conversationContext,
+    getPreparedConversationContext: (preparedState) => preparedState.conversationContext,
     decideSubscribedReply: services.subscribedReplyPolicy,
     recordSkippedSubscribedMessage: async ({
       thread,
@@ -21717,11 +21216,31 @@ function pluginConfigFromAgentPlugins(plugins) {
   ];
   return packages.length ? { packages } : void 0;
 }
+async function resolveAgentPluginBaseConfig(plugins) {
+  if (plugins.length === 0) {
+    return resolveVirtualPluginConfig();
+  }
+  return resolveBuildPluginConfig();
+}
+function mountAgentPluginRoutes(app, routes) {
+  for (const route of routes) {
+    const handler = (c) => route.handler(c.req.raw);
+    const methods = Array.isArray(route.method) ? route.method : [route.method ?? "ALL"];
+    const explicitMethods = methods.filter(
+      (method) => method !== "ALL"
+    );
+    if (methods.includes("ALL")) {
+      app.all(route.path, handler);
+    } else if (explicitMethods.length > 0) {
+      app.on(explicitMethods, route.path, handler);
+    }
+  }
+}
 async function createApp(options) {
   const configuredPlugins = options?.plugins;
   const agentPlugins2 = isJuniorPluginArray(configuredPlugins) ? configuredPlugins : [];
   const pluginConfig = isJuniorPluginArray(configuredPlugins) ? mergePluginConfig(
-    await resolveVirtualPluginConfig(),
+    await resolveAgentPluginBaseConfig(configuredPlugins),
     pluginConfigFromAgentPlugins(configuredPlugins)
   ) : configuredPlugins ?? await resolveBuildPluginConfig();
   validateAgentPlugins(agentPlugins2);
@@ -21729,11 +21248,13 @@ async function createApp(options) {
   const previousPluginConfig = setPluginConfig(pluginConfig);
   const previousAgentPlugins = setAgentPlugins(agentPlugins2);
   const previousConfigDefaults = getConfigDefaults();
+  let agentPluginRoutes = [];
   try {
     setConfigDefaults(options?.configDefaults);
     if (shouldValidatePluginCatalog) {
       getPluginCatalogSignature();
     }
+    agentPluginRoutes = getAgentPluginRoutes();
   } catch (error) {
     setPluginConfig(previousPluginConfig);
     setAgentPlugins(previousAgentPlugins);
@@ -21752,6 +21273,7 @@ async function createApp(options) {
     }
     await next();
   });
+  mountAgentPluginRoutes(app, agentPluginRoutes);
   app.get("/", () => GET());
   app.get("/health", () => GET());
   app.get("/api/oauth/callback/mcp/:provider", (c) => {