@sentry/junior 0.132.0 → 0.134.0

package/dist/{chunk-ZMV2YBT6.js → chunk-NF2TNZPD.js}

@@ -30,30 +30,41 @@ import {
   toMcpProviderError,
   toolInvocationDestination,
   uploadFilesToConversation
-} from "./chunk-SKWIIUS7.js";
+} from "./chunk-VGXJMECA.js";
 import {
+  AGENTS_REMOVAL_NOTICE,
+  AGENTS_REPLACEMENT_NOTICE,
   CooperativeTurnYieldError,
+  DEFAULT_SEARCH_COMMAND_TIMEOUT_MS,
   JUNIOR_THREAD_STATE_TTL_MS,
+  MAX_TEXT_CHARS,
   NO_REPLY_MARKER,
+  RIPGREP_EXCLUDED_GLOBS,
   TURN_CONTEXT_TAG,
   TurnInputCommitLostError,
   TurnSliceLimitExceededError,
   abandonReplacedPendingAuth,
+  buildAgentsInstructionsMessage,
   canReusePendingAuthLink,
+  collectFiles,
   containsNoReplyMarker,
   decideReply,
   estimateTextTokens,
   extractAssistantText,
+  findSingleRepositoryDirectory,
+  findVisibleAgentsInstructions,
   getAgentContextCompactionTriggerTokens,
   getAgentContextInputLimitTokens,
   getAssistantReplyText,
   getPiMessageRole,
+  getRipgrepSearchLocation,
   getTerminalAssistantMessages,
   getUserMessageInstructionText,
   hasRuntimeTurnContext,
   historyItemFromPiMessage,
   isAssistantMessage,
   isContinuablePiBoundary,
+  isMissingPathError,
   isNoReplyMarker,
   isToolResultError,
   isToolResultMessage,
@@ -63,6 +74,8 @@ import {
   loadTurnRoute,
   loadTurnSessionRecord,
   mergeArtifactsState,
+  missingPathSearchResult,
+  normalizeToLf,
   normalizeToolNameFromResult,
   openConversationProjection,
   persistAuthPauseSessionRecord,
@@ -70,17 +83,22 @@ import {
   persistRunningSessionRecord,
   persistYieldSessionRecord,
   piMessageFromHistoryItem,
+  positiveInteger,
   recordAuthorizationRequested,
   recordGuardianActionReviewed,
   recordMcpProviderConnected,
   recordToolExecutionStarted,
   recordTurnRoute,
+  renderAgentsInstructions,
+  resolveRepositoryInstructions,
+  resolveWorkspacePath,
   retainRuntimeTurnContext,
   sanitizeAssistantText,
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages,
+  truncateText,
   updateConversationStats
-} from "./chunk-GPXVDJML.js";
+} from "./chunk-7GKQ7UIO.js";
 import {
   parseSandboxEgressAuthRequiredSignal,
   parseSandboxEgressPermissionDeniedSignal,
@@ -89,6 +107,7 @@ import {
 } from "./chunk-EPBBYMNE.js";
 import {
   bindSandboxFileSystem,
+  buildCommandScript,
   buildNonInteractiveShellScript,
   createSandboxSession,
   getSandboxResources,
@@ -104,10 +123,9 @@ import {
   runNonInteractiveCommand,
   throwSandboxOperationError,
   wrapSandboxSetupError
-} from "./chunk-AW5Z3T7V.js";
+} from "./chunk-YNLQQ622.js";
 import {
   SCHEDULED_TASK_SYSTEM_ACTOR,
-  ToolInputError,
   compactEventTask,
   createEventTask,
   createSchedulerSqlStore,
@@ -136,14 +154,15 @@ import {
   resolveLocalScheduleAtMs,
   saveEventTask,
   writableEventTask
-} from "./chunk-XN656LB4.js";
+} from "./chunk-KWGJG4HO.js";
 import {
   parseSlackThreadId
-} from "./chunk-G3WYA2RS.js";
+} from "./chunk-MFERLE3G.js";
 import {
+  ToolInputError,
   addAgentTurnUsage,
   hasAgentTurnUsage
-} from "./chunk-HX236W2U.js";
+} from "./chunk-CDQ4YIZM.js";
 import {
   privateTraceResultAttributes
 } from "./chunk-UIE3R5XU.js";
@@ -162,7 +181,7 @@ import {
   readActorIdentity,
   resolveChannelCapabilities,
   withSlackRetries
-} from "./chunk-ALDPUN3Z.js";
+} from "./chunk-TR6UEEYD.js";
 import {
   KNOWN_CONVERSATION_EVENT_TYPES,
   contextProvenance,
@@ -173,7 +192,7 @@ import {
   instructionActors,
   instructionProvenanceFor,
   sameActorIdentity
-} from "./chunk-WYQP7QSB.js";
+} from "./chunk-VPYKNCTN.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
@@ -183,7 +202,7 @@ import {
   sandboxSkillFile,
   sandboxSkillPathResolution,
   sleep
-} from "./chunk-ODIP5CEM.js";
+} from "./chunk-FDNAUM7X.js";
 import {
   ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX,
   COMPACTION_SUMMARY_PREFIX,
@@ -217,7 +236,7 @@ import {
   renderCurrentInstruction,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-NNHUGGO4.js";
+} from "./chunk-XG5PHKPM.js";
 import {
   canExposeConversationPayload,
   resolveConversationPrivacy,
@@ -227,16 +246,16 @@ import {
   toGenAiMessagesTraceAttributes,
   toGenAiPayloadMetadata,
   toGenAiPayloadTraceAttributes
-} from "./chunk-ISNRPCPG.js";
+} from "./chunk-LKK4XMUV.js";
 import {
   discoverSkills,
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-BKE47OOW.js";
+} from "./chunk-S6DMTEOM.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-B7IY6SVJ.js";
+} from "./chunk-VEGF62FV.js";
 import {
   CredentialUnavailableError,
   OAuthProviderError,
@@ -244,7 +263,7 @@ import {
   getOAuthProviderErrorAttributes,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv
-} from "./chunk-V44FFBO3.js";
+} from "./chunk-VP6NCPRS.js";
 import {
   credentialUserSubjectId
 } from "./chunk-77VDLF3Z.js";
@@ -273,7 +292,7 @@ import {
   summarizeMessageText,
   withLogContext,
   withSpan
-} from "./chunk-GOEZU33G.js";
+} from "./chunk-6T3AYZT7.js";
 import {
   startInactiveSpan,
   withActiveSpan
@@ -568,6 +587,56 @@ var SkillSandbox = class {
   }
 };
 
+// src/chat/agent/repository-context.ts
+function findRestoredInstructions(messages, provenance) {
+  const restoredContext = messages?.map((message, index) => ({ message, provenance: provenance?.[index] })).reverse().find(
+    ({ message, provenance: messageProvenance }) => messageProvenance?.authority === "context" ? Boolean(findVisibleAgentsInstructions([message])) : false
+  );
+  return restoredContext ? findVisibleAgentsInstructions([restoredContext.message]) : void 0;
+}
+function createRepositoryInstructionsContext(options) {
+  const visibleInstructions = options.shouldPromptAgent ? findVisibleAgentsInstructions([
+    {
+      role: "user",
+      content: options.promptContextContentParts
+    }
+  ]) : findRestoredInstructions(
+    options.restoredMessages,
+    options.restoredProvenance
+  );
+  let instructionsVisible = visibleInstructions?.active === true;
+  let visibleFingerprint = options.initialInstructions && visibleInstructions?.active === true && visibleInstructions.directory === options.initialInstructions.directory && visibleInstructions.text === options.initialInstructions.text ? options.initialInstructions.fingerprint : void 0;
+  return {
+    async applyUpdate(currentUpdate, currentContext) {
+      if (!options.hasSandbox()) {
+        return currentUpdate;
+      }
+      const instructions = await options.capture();
+      if (instructions && instructions.fingerprint === visibleFingerprint && instructionsVisible) {
+        return currentUpdate;
+      }
+      if (!instructions && !instructionsVisible) {
+        return currentUpdate;
+      }
+      const message = instructions ? buildAgentsInstructionsMessage({
+        directory: instructions.directory,
+        text: instructionsVisible ? `${AGENTS_REPLACEMENT_NOTICE}
+
+${instructions.text}` : instructions.text
+      }) : buildAgentsInstructionsMessage({ text: AGENTS_REMOVAL_NOTICE });
+      const context = currentUpdate?.context ?? currentContext;
+      const messages = [...context.messages, message];
+      options.setMessages(messages);
+      visibleFingerprint = instructions?.fingerprint;
+      instructionsVisible = Boolean(instructions);
+      return {
+        ...currentUpdate,
+        context: { ...context, messages }
+      };
+    }
+  };
+}
+
 // src/chat/pi/traced-stream.ts
 import {
   streamSimple
@@ -1302,11 +1371,11 @@ function projectToolActionRejection(pending, toolCallId, result) {
 function restoreToolActionRejections(messages) {
   const priorRejections = [];
   for (const message of messages) {
-    const record = message;
-    if (record.role !== "toolResult" || record.isError !== true) {
+    const record2 = message;
+    if (record2.role !== "toolResult" || record2.isError !== true) {
       continue;
     }
-    const rejection = getToolActionRejectionMarker(record);
+    const rejection = getToolActionRejectionMarker(record2);
     if (!rejection) {
       continue;
     }
@@ -1806,6 +1875,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 actor is the person asking now, which may differ from the original reporter or subject.",
+  "- Direct system/developer/user instructions (as part of a prompt) take precedence over AGENTS.md instructions.",
   "- Runtime owns continuation and authorization notices; on resumed turns, answer with the final requested content only."
 ];
 var SLACK_ACTION_RULES = [
@@ -2082,7 +2152,6 @@ function buildTurnContextPrompt(params) {
   const sections = [
     `<${TURN_CONTEXT_TAG}>`,
     TURN_CONTEXT_HEADER,
-    "The current user instruction appears after this block in `<current-instruction>` in the same message.",
     ...runtimeSections,
     `</${TURN_CONTEXT_TAG}>`
   ].filter((section) => Boolean(section));
@@ -2103,17 +2172,8 @@ function renderThreadContextForPrompt(context) {
   }
   return ["<thread-background>", context, "</thread-background>"].join("\n");
 }
-function buildUserTurnText(userInput, conversationContext, actor) {
-  const trimmedContext = conversationContext?.trim();
-  const currentInstruction = renderCurrentInstruction(userInput, actor);
-  if (!trimmedContext) {
-    return currentInstruction;
-  }
-  return [
-    renderThreadContextForPrompt(trimmedContext),
-    "",
-    currentInstruction
-  ].join("\n");
+function buildUserTurnText(userInput, actor) {
+  return renderCurrentInstruction(userInput, actor);
 }
 function renderExplicitSkillInstructions(skill) {
   return [
@@ -2246,24 +2306,24 @@ function buildUserTurnInput(args) {
       })
     });
   }
-  return { routerBlocks, userContentParts };
+  return { contextContentParts: [], routerBlocks, userContentParts };
 }
 function buildPromptInput(input) {
   const promptConversationContext = input.piMessages && input.piMessages.length > 0 && !input.includeConversationContextWithPiMessages ? void 0 : input.conversationContext;
-  const userTurnText = buildUserTurnText(
-    input.messageText,
-    promptConversationContext,
-    input.actor
-  );
-  return buildUserTurnInput({
+  const promptInput = buildUserTurnInput({
     omittedImageAttachmentCount: input.omittedImageAttachmentCount ?? 0,
     userAttachments: input.userAttachments,
-    userTurnText
+    userTurnText: buildUserTurnText(input.messageText, input.actor)
   });
+  const trimmedContext = promptConversationContext?.trim();
+  return {
+    ...promptInput,
+    contextContentParts: trimmedContext ? [{ type: "text", text: renderThreadContextForPrompt(trimmedContext) }] : []
+  };
 }
 function buildSteeringPiMessage(message) {
   const { userContentParts } = buildUserTurnInput({
-    userTurnText: buildUserTurnText(message.text, void 0, message.actor),
+    userTurnText: buildUserTurnText(message.text, message.actor),
     userAttachments: message.userAttachments,
     omittedImageAttachmentCount: message.omittedImageAttachmentCount ?? 0
   });
@@ -2275,19 +2335,25 @@ function buildSteeringPiMessage(message) {
 }
 function withoutTrailingUncheckpointedUserPrompt(messages, userContentParts) {
   if (!messages || messages.length === 0) {
-    return [];
+    return { messages: [] };
   }
   const lastMessage = messages.at(-1);
   if (lastMessage?.role !== "user") {
-    return messages;
+    return { messages };
   }
   const comparableLastMessage = stripRuntimeTurnContext([
     lastMessage
   ])[0];
   if (!userPromptContentMatches(comparableLastMessage?.content, userContentParts)) {
-    return messages;
+    return { messages };
+  }
+  const promptTimestamp = typeof lastMessage.timestamp === "number" ? lastMessage.timestamp : void 0;
+  const withoutPrompt = messages.slice(0, -1);
+  const previousMessage = withoutPrompt.at(-1);
+  if (previousMessage && stripRuntimeTurnContext([previousMessage, lastMessage]).length === 1) {
+    return { messages: withoutPrompt.slice(0, -1), promptTimestamp };
   }
-  return messages.slice(0, -1);
+  return { messages: withoutPrompt, promptTimestamp };
 }
 function userPromptContentMatches(storedContent, currentContent) {
   return isDeepStrictEqual(storedContent, currentContent);
@@ -2301,53 +2367,58 @@ function isUserContentPart(value) {
   }
   return value.type === "image" && "data" in value && typeof value.data === "string" && "mimeType" in value && typeof value.mimeType === "string";
 }
-function checkpointedPromptContent(args) {
-  if (!args.messages || args.turnStartMessageIndex === void 0 || args.turnStartMessageIndex !== args.messages.length - 1) {
+function checkpointedPrompt(args) {
+  if (!args.messages || args.turnStartMessageIndex === void 0 || args.turnStartMessageIndex >= args.messages.length) {
     return void 0;
   }
-  const message = args.messages[args.turnStartMessageIndex];
+  const turnMessages = args.messages.slice(args.turnStartMessageIndex);
+  const durableTurnMessages = stripRuntimeTurnContext(turnMessages);
+  if (durableTurnMessages.length !== 1) {
+    return void 0;
+  }
+  const message = durableTurnMessages[0];
   if (message?.role !== "user" || !Array.isArray(message.content)) {
     return void 0;
   }
-  const durableMessage = stripRuntimeTurnContext([message])[0];
-  if (!userPromptContentMatches(durableMessage?.content, args.userContentParts)) {
+  if (!userPromptContentMatches(message.content, args.userContentParts)) {
     return void 0;
   }
-  const content = message.content;
-  if (!content.every(isUserContentPart)) {
+  if (!message.content.every(isUserContentPart)) {
     return void 0;
   }
-  return content;
+  const contextContentParts = retainRuntimeTurnContext(turnMessages).flatMap(
+    (runtimeMessage) => {
+      const content = runtimeMessage.content;
+      return Array.isArray(content) && content.every(isUserContentPart) ? content : [];
+    }
+  );
+  return {
+    contextContentParts,
+    userContentParts: message.content
+  };
 }
 async function assemblePrompt(args) {
   const source = args.routing.source;
   const hasPromptCheckpoint = args.resumedFromSessionRecord && args.existingTurnStartMessageIndex !== void 0;
   const shouldPromptAgent = !args.resumedFromSessionRecord || !hasPromptCheckpoint;
-  const requestContentParts = [
-    ...args.explicitSkill ? [
-      {
-        type: "text",
-        text: renderExplicitSkillInstructions(args.explicitSkill)
-      }
-    ] : [],
-    ...args.userContentParts
-  ];
-  const promptHistoryMessages = shouldPromptAgent ? withoutTrailingUncheckpointedUserPrompt(
+  const requestContentParts = args.userContentParts;
+  const trimmedPrompt = shouldPromptAgent ? withoutTrailingUncheckpointedUserPrompt(
     args.priorPiMessages,
     requestContentParts
-  ) : args.existingSessionPiMessages;
-  const replayedPromptContent = shouldPromptAgent && !args.resumedFromSessionRecord ? checkpointedPromptContent({
+  ) : { messages: args.existingSessionPiMessages };
+  const promptHistoryMessages = trimmedPrompt.messages;
+  const replayedPrompt = shouldPromptAgent && !args.resumedFromSessionRecord ? checkpointedPrompt({
     messages: args.existingSessionPiMessages,
     turnStartMessageIndex: args.existingTurnStartMessageIndex,
     userContentParts: requestContentParts
   }) : void 0;
-  const needsBootstrapContextForPrompt = shouldPromptAgent && !replayedPromptContent && !hasRuntimeTurnContext(promptHistoryMessages);
+  const needsBootstrapContextForPrompt = shouldPromptAgent && !replayedPrompt && !hasRuntimeTurnContext(promptHistoryMessages);
   const systemPromptContributions = await getPluginSystemPromptContributions(source);
   const pluginSystemPrompt = buildPluginSystemPromptContributions(
     systemPromptContributions
   );
   const baseInstructions = [buildSystemPrompt({ source }), pluginSystemPrompt].filter((section) => Boolean(section)).join("\n\n");
-  const pluginUserPromptContributions = !shouldPromptAgent || replayedPromptContent ? [] : await getPluginUserPromptContributions({
+  const pluginUserPromptContributions = !shouldPromptAgent || replayedPrompt ? [] : await getPluginUserPromptContributions({
     context: args.toolRuntimeContext,
     turnId: args.turnId
   });
@@ -2371,18 +2442,33 @@ async function assemblePrompt(args) {
     configuration: args.configurationValues
   }) : null;
   const turnContextParts = turnContextPrompt ? [{ type: "text", text: turnContextPrompt }] : [];
-  const promptContentParts = replayedPromptContent ?? [
+  const contextContentParts = replayedPrompt?.contextContentParts ?? [
     ...turnContextParts,
-    ...requestContentParts
+    ...args.explicitSkill ? [
+      {
+        type: "text",
+        text: renderExplicitSkillInstructions(args.explicitSkill)
+      }
+    ] : [],
+    ...args.contextContentParts
   ];
+  const userContentParts = replayedPrompt?.userContentParts ?? requestContentParts;
   const inputMessages = [
     {
       role: "system",
       content: [{ type: "text", text: baseInstructions }]
     },
+    ...contextContentParts.length > 0 ? [
+      {
+        role: "user",
+        content: contextContentParts.map(
+          (part) => toObservablePromptPart(part)
+        )
+      }
+    ] : [],
     {
       role: "user",
-      content: promptContentParts.map((part) => toObservablePromptPart(part))
+      content: userContentParts.map((part) => toObservablePromptPart(part))
     }
   ];
   const inputMessagesAttribute = serializeGenAiAttribute(
@@ -2391,9 +2477,17 @@ async function assemblePrompt(args) {
         role: "system",
         parts: [{ type: "text", content: baseInstructions }]
       },
+      ...contextContentParts.length > 0 ? [
+        {
+          role: "user",
+          parts: contextContentParts.flatMap(
+            (part) => part.type === "text" ? [{ type: "text", content: part.text }] : []
+          )
+        }
+      ] : [],
       {
         role: "user",
-        parts: promptContentParts.flatMap(
+        parts: userContentParts.flatMap(
           (part) => part.type === "text" ? [{ type: "text", content: part.text }] : []
         )
       }
@@ -2401,14 +2495,16 @@ async function assemblePrompt(args) {
   );
   return {
     baseInstructions,
+    contextContentParts,
     inputMessages,
     inputMessagesAttribute,
-    promptContentParts,
+    ...trimmedPrompt.promptTimestamp !== void 0 ? { promptTimestamp: trimmedPrompt.promptTimestamp } : {},
     promptHistoryMessages,
     shouldPromptAgent,
     turnContexts: pluginUserPromptContributions.flatMap(
       (contribution) => contribution.context ? [contribution.context] : []
-    )
+    ),
+    userContentParts
   };
 }
 
@@ -2967,8 +3063,8 @@ function sandboxProxyUrl(credentialToken) {
       "Cannot determine base URL for sandbox credential egress (set JUNIOR_BASE_URL or deploy to Vercel)"
     );
   }
-  const path9 = credentialToken ? `${SANDBOX_EGRESS_PROXY_PATH}/${credentialToken}` : SANDBOX_EGRESS_PROXY_PATH;
-  return new URL(path9, baseUrl).toString();
+  const path8 = credentialToken ? `${SANDBOX_EGRESS_PROXY_PATH}/${credentialToken}` : SANDBOX_EGRESS_PROXY_PATH;
+  return new URL(path8, baseUrl).toString();
 }
 function buildSandboxEgressNetworkPolicy(input) {
   const allow = {
@@ -3776,7 +3872,7 @@ function createSandboxRuntime(options) {
           const commandResult2 = await sandboxInstance.runCommand({
             cmd: "bash",
             args: ["-c", script],
-            cwd: SANDBOX_WORKSPACE_ROOT,
+            cwd: input.cwd ?? SANDBOX_WORKSPACE_ROOT,
             signal: controller.signal
           });
           return await readCommandOutput(commandResult2);
@@ -3844,191 +3940,6 @@ function createSandboxRuntime(options) {
   };
 }
 
-// src/chat/tools/sandbox/file-utils.ts
-import path4 from "path";
-var MAX_TEXT_CHARS = 6e4;
-var RIPGREP_EXCLUDED_GLOBS = [
-  "!**/.git/**",
-  "!**/node_modules/**"
-];
-var DEFAULT_SEARCH_COMMAND_TIMEOUT_MS = 3e4;
-var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([".git", "node_modules"]);
-function positiveInteger(value) {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    return void 0;
-  }
-  const integer = Math.floor(value);
-  return integer > 0 ? integer : void 0;
-}
-function normalizeToLf(value) {
-  return value.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-}
-function truncateText(value, maxChars = MAX_TEXT_CHARS) {
-  if (value.length <= maxChars) {
-    return { content: value, truncated: false };
-  }
-  const removed = value.length - maxChars;
-  return {
-    content: `${value.slice(0, maxChars)}
-
-[output truncated: ${removed} characters removed]`,
-    truncated: true
-  };
-}
-function isMissingPathError(error) {
-  if (!error || typeof error !== "object") {
-    return false;
-  }
-  const candidate = error;
-  if (candidate.code === "ENOENT") {
-    return true;
-  }
-  return typeof candidate.message === "string" && candidate.message.startsWith("File not found:");
-}
-function missingPathSearchResult(params) {
-  const textPath = params.displayPath ?? params.missingPath ?? params.path;
-  throw new ToolInputError(`Path not found: ${textPath}`);
-}
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function globToRegExp(pattern) {
-  let source = "";
-  for (let index = 0; index < pattern.length; index += 1) {
-    const char = pattern[index];
-    const next = pattern[index + 1];
-    if (char === "*" && next === "*") {
-      if (pattern[index + 2] === "/") {
-        source += "(?:.*/)?";
-        index += 2;
-        continue;
-      }
-      source += ".*";
-      index += 1;
-      continue;
-    }
-    if (char === "*") {
-      source += "[^/]*";
-      continue;
-    }
-    if (char === "?") {
-      source += "[^/]";
-      continue;
-    }
-    source += escapeRegExp(char);
-  }
-  return new RegExp(`^${source}$`);
-}
-function matchesGlob(relativePath, pattern) {
-  const matcher = globToRegExp(pattern);
-  if (matcher.test(relativePath)) {
-    return true;
-  }
-  if (pattern.startsWith("**/") && matchesGlob(relativePath, pattern.slice(3))) {
-    return true;
-  }
-  return !pattern.includes("/") && matcher.test(path4.posix.basename(relativePath));
-}
-function resolveWorkspacePath(input, fallback = ".") {
-  const requested = (input ?? "").trim() || 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 ToolInputError(
-      `Path must stay within ${SANDBOX_WORKSPACE_ROOT}: ${requested}`
-    );
-  }
-  return normalized;
-}
-function getRipgrepSearchLocation(root, rootIsDirectory) {
-  if (rootIsDirectory) {
-    return { cwd: root, target: "." };
-  }
-  return {
-    cwd: path4.posix.dirname(root),
-    target: path4.posix.basename(root)
-  };
-}
-async function collectFiles(params) {
-  const files = [];
-  let limitReached = false;
-  let missingPath;
-  const visit = async (dirPath) => {
-    if (missingPath) {
-      return;
-    }
-    let entries;
-    try {
-      entries = (await params.fs.readdir(dirPath)).sort(
-        (a, b) => a.toLowerCase().localeCompare(b.toLowerCase())
-      );
-    } catch (error) {
-      if (isMissingPathError(error)) {
-        missingPath = dirPath;
-        return;
-      }
-      throw error;
-    }
-    for (const entry of entries) {
-      const fullPath = path4.posix.join(dirPath, entry);
-      let stat2;
-      try {
-        stat2 = await params.fs.stat(fullPath);
-      } catch (error) {
-        if (isMissingPathError(error)) {
-          missingPath = fullPath;
-          return;
-        }
-        throw error;
-      }
-      if (stat2.isDirectory()) {
-        if (!SKIPPED_DIRECTORIES.has(entry)) {
-          await visit(fullPath);
-        }
-        if (limitReached) return;
-        continue;
-      }
-      const relativePath = path4.posix.relative(params.root, fullPath);
-      if (!params.pattern || matchesGlob(relativePath, params.pattern)) {
-        files.push(fullPath);
-        if (params.limit && files.length >= params.limit) {
-          limitReached = true;
-          return;
-        }
-      }
-    }
-  };
-  let stat;
-  try {
-    stat = await params.fs.stat(params.root);
-  } catch (error) {
-    if (isMissingPathError(error)) {
-      return {
-        files,
-        limitReached: false,
-        missingPath: params.root,
-        missingRoot: true
-      };
-    }
-    throw error;
-  }
-  if (!stat.isDirectory()) {
-    const relativePath = path4.posix.basename(params.root);
-    return {
-      files: !params.pattern || matchesGlob(relativePath, params.pattern) ? [params.root] : [],
-      limitReached: false,
-      missingRoot: false
-    };
-  }
-  await visit(params.root);
-  return {
-    files,
-    limitReached,
-    missingPath,
-    missingRoot: missingPath === params.root
-  };
-}
-
 // src/chat/tools/sandbox/text-edits.ts
 var MAX_DIFF_LINE_CHARS = 4e3;
 function truncateDiffLine(value) {
@@ -4094,12 +4005,12 @@ function prepareTextReplacementArguments(input) {
       if (!edit || typeof edit !== "object") {
         return edit;
       }
-      const record = edit;
-      const { old_text, new_text, ...rest } = record;
+      const record2 = edit;
+      const { old_text, new_text, ...rest } = record2;
       return {
         ...rest,
-        oldText: record.oldText ?? old_text,
-        newText: record.newText ?? new_text
+        oldText: record2.oldText ?? old_text,
+        newText: record2.newText ?? new_text
       };
     });
   }
@@ -4242,8 +4153,8 @@ function parseToolContent(content) {
   }
   return content;
 }
-function formatZodPath(path9) {
-  return path9.length > 0 ? path9.map(String).join(".") : "root";
+function formatZodPath(path8) {
+  return path8.length > 0 ? path8.map(String).join(".") : "root";
 }
 function formatToolInputError(error) {
   const details = error.issues.slice(0, 5).map((issue) => `${formatZodPath(issue.path)}: ${issue.message}`).join("; ");
@@ -4390,7 +4301,7 @@ function createEditFileTool() {
 }
 
 // src/chat/tools/sandbox/find-files.ts
-import path5 from "path";
+import path4 from "path";
 import { z as z5 } from "zod";
 var DEFAULT_FIND_LIMIT = 100;
 async function findFiles(params) {
@@ -4423,7 +4334,7 @@ async function findFiles(params) {
     });
   }
   const relativePaths = files.map(
-    (filePath) => path5.posix.relative(root, filePath)
+    (filePath) => path4.posix.relative(root, filePath)
   );
   const bounded = truncateText(
     relativePaths.length > 0 ? relativePaths.join("\n") : "No files found matching pattern"
@@ -4509,8 +4420,8 @@ async function findFilesWithRipgrep(params) {
     throw new Error(`ripgrep file search failed: ${detail}`);
   }
   const allPaths = result.stdout.split("\0").filter(Boolean).map((filePath) => {
-    const absolute = filePath.startsWith("/") ? path5.posix.normalize(filePath) : path5.posix.resolve(location.cwd, filePath);
-    return rootIsDirectory ? path5.posix.relative(params.root, absolute) : path5.posix.basename(absolute);
+    const absolute = filePath.startsWith("/") ? path4.posix.normalize(filePath) : path4.posix.resolve(location.cwd, filePath);
+    return rootIsDirectory ? path4.posix.relative(params.root, absolute) : path4.posix.basename(absolute);
   });
   const limitReached = allPaths.length > params.limit;
   const relativePaths = allPaths.slice(0, params.limit);
@@ -4583,7 +4494,7 @@ function createFindFilesTool() {
 }
 
 // src/chat/tools/sandbox/grep.ts
-import path6 from "path";
+import path5 from "path";
 import { z as z6 } from "zod";
 var DEFAULT_GREP_LIMIT = 100;
 var MAX_GREP_LINE_CHARS = 500;
@@ -4674,7 +4585,7 @@ async function grepFiles(params) {
       continue;
     }
     const lines = normalizeToLf(content).split("\n");
-    const relativePath = files.length === 1 && filePath === root ? path6.posix.basename(filePath) : path6.posix.relative(root, filePath);
+    const relativePath = files.length === 1 && filePath === root ? path5.posix.basename(filePath) : path5.posix.relative(root, filePath);
     const matchedLines = [];
     for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
       if (!lineMatches({
@@ -4813,37 +4724,37 @@ async function grepFilesWithRipgrep(params) {
     if (!rawLine) {
       continue;
     }
-    let record;
+    let record2;
     try {
-      record = JSON.parse(rawLine);
+      record2 = JSON.parse(rawLine);
     } catch (error) {
       throw new Error("ripgrep returned invalid JSON output", { cause: error });
     }
     parsedRecordCount += 1;
-    if (record.type !== "match" && record.type !== "context") {
+    if (record2.type !== "match" && record2.type !== "context") {
       continue;
     }
-    const line = record.data?.line_number;
-    const rawPath = decodeRipgrepText(record.data?.path);
+    const line = record2.data?.line_number;
+    const rawPath = decodeRipgrepText(record2.data?.path);
     if (!line || !rawPath) {
       continue;
     }
-    const absolutePath = rawPath.startsWith("/") ? path6.posix.normalize(rawPath) : path6.posix.resolve(location.cwd, rawPath);
-    const displayPath = rootIsDirectory ? path6.posix.relative(params.root, absolutePath) : path6.posix.basename(absolutePath);
+    const absolutePath = rawPath.startsWith("/") ? path5.posix.normalize(rawPath) : path5.posix.resolve(location.cwd, rawPath);
+    const displayPath = rootIsDirectory ? path5.posix.relative(params.root, absolutePath) : path5.posix.basename(absolutePath);
     let records = recordsByPath.get(displayPath);
     if (!records) {
       records = [];
       recordsByPath.set(displayPath, records);
       pathOrder.push(displayPath);
     }
-    const matched = record.type === "match";
+    const matched = record2.type === "match";
     if (matched) {
       totalMatches += 1;
     }
     records.push({
       line,
       matched,
-      text: decodeRipgrepText(record.data?.lines).replace(/\r?\n$/, "")
+      text: decodeRipgrepText(record2.data?.lines).replace(/\r?\n$/, "")
     });
   }
   let remainingMatches = params.limit;
@@ -4852,9 +4763,9 @@ async function grepFilesWithRipgrep(params) {
   for (const displayPath of pathOrder) {
     const records = recordsByPath.get(displayPath) ?? [];
     const selectedMatchLines = [];
-    for (const record of records) {
-      if (record.matched && remainingMatches > 0) {
-        selectedMatchLines.push(record.line);
+    for (const record2 of records) {
+      if (record2.matched && remainingMatches > 0) {
+        selectedMatchLines.push(record2.line);
         remainingMatches -= 1;
       }
     }
@@ -4863,22 +4774,22 @@ async function grepFilesWithRipgrep(params) {
     }
     const selectedMatchSet = new Set(selectedMatchLines);
     const emittedLines = /* @__PURE__ */ new Set();
-    for (const record of records) {
-      if (emittedLines.has(record.line)) {
+    for (const record2 of records) {
+      if (emittedLines.has(record2.line)) {
         continue;
       }
       const include = selectedMatchLines.some(
-        (matchLine) => Math.abs(record.line - matchLine) <= params.context
+        (matchLine) => Math.abs(record2.line - matchLine) <= params.context
       );
       if (!include) {
         continue;
       }
-      emittedLines.add(record.line);
-      const truncated = truncateGrepLine(record.text);
+      emittedLines.add(record2.line);
+      const truncated = truncateGrepLine(record2.text);
       lineTruncated ||= truncated.truncated;
-      const separator = selectedMatchSet.has(record.line) ? ":" : "-";
+      const separator = selectedMatchSet.has(record2.line) ? ":" : "-";
       output.push(
-        `${displayPath}${separator}${record.line}${separator} ${truncated.line}`
+        `${displayPath}${separator}${record2.line}${separator} ${truncated.line}`
       );
     }
   }
@@ -4961,7 +4872,7 @@ function createGrepTool() {
 }
 
 // src/chat/tools/sandbox/list-dir.ts
-import path7 from "path";
+import path6 from "path";
 import { z as z7 } from "zod";
 var DEFAULT_LIST_LIMIT = 500;
 async function listDir(params) {
@@ -4997,7 +4908,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() ? "/" : ""}`);
@@ -5139,8 +5050,8 @@ function sliceFileContent(params) {
     } : {}
   });
 }
-function missingFileResult(path9) {
-  throw new ToolInputError(`File not found: ${path9}`);
+function missingFileResult(path8) {
+  throw new ToolInputError(`File not found: ${path8}`);
 }
 
 // src/chat/tools/sandbox/read-file.ts
@@ -5324,6 +5235,7 @@ function createSandbox(options) {
   };
   const executeBashTool = async (rawInput, command, context) => {
     const env = parseEnv(rawInput.env);
+    const cwd = typeof rawInput.cwd === "string" ? resolveWorkspacePath(rawInput.cwd) : SANDBOX_WORKSPACE_ROOT;
     const timeoutMs = positiveInteger(rawInput.timeoutMs);
     logSandboxBootRequest("tool.bash", {
       "app.sandbox.command_length": command.length
@@ -5340,6 +5252,7 @@ function createSandbox(options) {
         try {
           const response = await executeBash({
             command,
+            cwd,
             ...env ? { env } : {},
             ...timeoutMs ? { timeoutMs } : {},
             ...context.signal ? { signal: context.signal } : {}
@@ -5371,7 +5284,7 @@ function createSandbox(options) {
     return formatSandboxCommandResult({
       ok: result.exitCode === 0,
       command,
-      cwd: SANDBOX_WORKSPACE_ROOT,
+      cwd,
       exit_code: result.exitCode,
       signal: null,
       timed_out: Boolean(result.timedOut),
@@ -5695,6 +5608,18 @@ function createSandbox(options) {
     })
   };
   return {
+    async captureRepositoryInstructions() {
+      if (!runtime.sandboxRef()) {
+        return void 0;
+      }
+      const { fs: fs5 } = await runtime.tools();
+      const selected = await findSingleRepositoryDirectory(fs5);
+      if (!selected) return void 0;
+      return await resolveRepositoryInstructions({
+        cwd: selected,
+        fs: fs5
+      });
+    },
     workspace,
     tools: {
       supports(toolName) {
@@ -5712,7 +5637,7 @@ function createSandbox(options) {
 }
 
 // src/chat/tools/sandbox/file-uploads.ts
-import path8 from "path";
+import path7 from "path";
 import { z as z9 } from "zod";
 var MAX_SANDBOX_FILE_UPLOAD_BYTES = 10 * 1024 * 1024;
 var SANDBOX_ARTIFACTS_DIR = "/tmp/junior/artifacts";
@@ -5748,9 +5673,9 @@ var MIME_BY_EXTENSION = {
   ".log": "text/plain"
 };
 var SandboxFileNotFoundError = class extends ToolInputError {
-  constructor(path9) {
-    super(`failed to read file: ${path9}`);
-    this.path = path9;
+  constructor(path8) {
+    super(`failed to read file: ${path8}`);
+    this.path = path8;
   }
   path;
 };
@@ -5759,27 +5684,27 @@ function normalizeSandboxPath(inputPath) {
   if (!trimmed) {
     throw new Error("path is required");
   }
-  if (path8.posix.isAbsolute(trimmed)) {
+  if (path7.posix.isAbsolute(trimmed)) {
     return trimmed;
   }
-  return path8.posix.join(SANDBOX_WORKSPACE_ROOT, trimmed);
+  return path7.posix.join(SANDBOX_WORKSPACE_ROOT, trimmed);
 }
 function sanitizeFilename(value, fallbackPath) {
   const candidate = (value ?? "").trim();
   if (candidate) {
-    const base = path8.posix.basename(candidate);
+    const base = path7.posix.basename(candidate);
     if (base && base !== "." && base !== "..") {
       return base;
     }
   }
-  const derived = path8.posix.basename(fallbackPath);
+  const derived = path7.posix.basename(fallbackPath);
   if (derived && derived !== "." && derived !== "..") {
     return derived;
   }
   return "attachment.bin";
 }
 function sandboxArtifactPath(filename) {
-  return path8.posix.join(
+  return path7.posix.join(
     SANDBOX_ARTIFACTS_DIR,
     sanitizeFilename(filename, "artifact.bin")
   );
@@ -5789,7 +5714,7 @@ function inferMimeType(filename, explicitMimeType) {
   if (explicit) {
     return explicit;
   }
-  const ext = path8.extname(filename).toLowerCase();
+  const ext = path7.extname(filename).toLowerCase();
   return MIME_BY_EXTENSION[ext] ?? "application/octet-stream";
 }
 async function detectMimeType(workspace, targetPath) {
@@ -5880,94 +5805,321 @@ async function writeSandboxGeneratedArtifacts(workspace, files) {
   return artifacts.map((artifact) => artifact.ref);
 }
 
-// src/chat/agent/sandbox.ts
-function bashCommand(input) {
-  if (!input || typeof input !== "object" || Array.isArray(input)) {
-    return void 0;
-  }
-  const command = input.command;
-  return typeof command === "string" && command.trim() ? command.trim() : void 0;
-}
-function createAgentSandbox(options) {
-  const sandbox = createSandbox({
-    sandboxRef: options.sandboxRef,
-    skills: options.skills,
-    referenceFiles: listReferenceFiles(),
-    traceContext: options.traceContext,
-    tracePropagation: options.tracePropagation,
-    egressSignals: options.egressSignals,
-    credentialEgress: options.credentialEgress,
-    prepare: options.prepareSandbox,
-    onSandboxRefChanged: async (sandboxRef) => {
-      options.onSandboxRefChanged(sandboxRef);
-      await options.persistSandboxRef?.(sandboxRef);
+// src/chat/tool-support/normalize-result.ts
+function isToolContent(value) {
+  return Array.isArray(value) && value.every((part) => {
+    if (!part || typeof part !== "object") {
+      return false;
     }
-  });
-  return {
-    workspace: sandbox.workspace,
-    sandboxRef: sandbox.sandboxRef,
-    close: sandbox.close,
-    tools: {
-      supports: sandbox.tools.supports,
-      async execute(params) {
-        const command = params.toolName === "bash" ? bashCommand(params.input) : void 0;
-        if (command) {
-          const result = await maybeExecuteJrRpcCustomCommand(command, {
-            activeSkill: options.getActiveSkill(),
-            channelConfiguration: options.channelConfiguration,
-            actorId: isUserActor(options.actor) ? options.actor.userId : void 0,
-            onConfigurationValueChanged: (key, value) => {
-              if (value === void 0) {
-                delete options.configurationValues[key];
-                return;
-              }
-              options.configurationValues[key] = value;
-            }
-          });
-          if (result.handled) {
-            return formatSandboxCommandResult(result.result);
-          }
-        }
-        return await sandbox.tools.execute(params);
-      }
-    },
-    async writeGeneratedArtifacts(files) {
-      return await writeSandboxGeneratedArtifacts(sandbox.workspace, files);
+    const record2 = part;
+    if (record2.type === "text") {
+      return typeof record2.text === "string";
     }
-  };
+    if (record2.type === "image") {
+      return typeof record2.data === "string" && typeof record2.mimeType === "string";
+    }
+    return false;
+  });
 }
-
-// src/chat/mcp/tool-manager.ts
-import {
-  missingToolAnnotationKeys
-} from "@sentry/junior-plugin-api";
-
-// src/chat/mcp/client.ts
-import { AsyncLocalStorage } from "async_hooks";
-import { Client } from "@modelcontextprotocol/sdk/client";
-import {
-  UnauthorizedError
-} from "@modelcontextprotocol/sdk/client/auth.js";
-import {
-  StreamableHTTPClientTransport,
-  StreamableHTTPError
-} from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-var MCP_CLIENT_INFO = {
-  name: "junior-mcp-client",
-  version: "1.0.0"
-};
-var MCP_TOOLS_CALL_METHOD = "tools/call";
-function getDefaultPort(url) {
-  if (url.protocol === "https:") {
-    return 443;
-  }
-  if (url.protocol === "http:") {
-    return 80;
-  }
-  return void 0;
+function isStructuredToolExecutionResult(value) {
+  const content = value?.content;
+  return typeof value === "object" && value !== null && isToolContent(content) && "details" in value;
 }
-function getMcpNetworkAttributes(url) {
-  const port = url.port ? Number(url.port) : getDefaultPort(url);
+function isContentOnlyToolExecutionResult(value) {
+  const content = value?.content;
+  return typeof value === "object" && value !== null && isToolContent(content) && !("details" in value);
+}
+function toToolContentText(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function withoutFirstGeneratedTextContent(content) {
+  const [first, ...rest] = content;
+  if (first?.type === "text") {
+    return rest;
+  }
+  return content;
+}
+function replaceGeneratedTextContent(content, text) {
+  return [
+    {
+      type: "text",
+      text
+    },
+    ...withoutFirstGeneratedTextContent(content)
+  ];
+}
+function isRecord3(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function hasContinuation(value) {
+  return isRecord3(value) && isRecord3(value.continuation);
+}
+function stringField(record2, key) {
+  const value = record2[key];
+  return typeof value === "string" ? value : "";
+}
+function numberField(record2, key) {
+  const value = record2[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function stringListField(record2, key) {
+  const value = record2[key];
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function accountText(value) {
+  if (!isRecord3(value)) {
+    return void 0;
+  }
+  const label = stringField(value, "label") || stringField(value, "id");
+  const id = stringField(value, "id");
+  if (!label) {
+    return void 0;
+  }
+  return id && id !== label ? `${label} (${id})` : label;
+}
+function upstreamPermissionDeniedText(value) {
+  if (!isRecord3(value) || !isRecord3(value.permission_denied)) {
+    return void 0;
+  }
+  const signal = value.permission_denied;
+  if (signal.source !== "upstream") {
+    return void 0;
+  }
+  const provider = stringField(signal, "provider");
+  const message = stringField(signal, "message");
+  const upstreamHost = stringField(signal, "upstreamHost");
+  const upstreamPath = stringField(signal, "upstreamPath");
+  const status = numberField(signal, "status");
+  if (!provider || !message || !upstreamHost || !upstreamPath || !status) {
+    return void 0;
+  }
+  const grant = isRecord3(signal.grant) ? signal.grant : {};
+  const grantName = stringField(grant, "name");
+  const grantAccess = stringField(grant, "access");
+  const grantReason = stringField(grant, "reason");
+  const grantRequirements = stringListField(grant, "requirements");
+  const account = accountText(signal.account);
+  const command = stringField(value, "command");
+  const stderr = stringField(value, "stderr").trim();
+  const stdout = stringField(value, "stdout").trim();
+  const acceptedPermissions = stringField(signal, "acceptedPermissions");
+  const sso = stringField(signal, "sso");
+  return [
+    "Upstream permission denied.",
+    message,
+    "",
+    `Provider: ${provider}`,
+    ...account ? [`Provider account: ${account}`] : [],
+    `Grant: ${grantName || "unknown"}${grantAccess ? ` (${grantAccess}${grantReason ? `, ${grantReason}` : ""})` : ""}`,
+    ...grantRequirements.length > 0 ? [
+      "Provider requirements:",
+      ...grantRequirements.map((item) => `- ${item}`)
+    ] : [],
+    `Upstream: ${upstreamHost}${upstreamPath}`,
+    `Status: ${status}`,
+    ...acceptedPermissions ? [`Accepted provider permissions: ${acceptedPermissions}`] : [],
+    ...sso ? [`Provider SSO: ${sso}`] : [],
+    ...command ? [`Command: ${command}`] : [],
+    "",
+    "Junior had a credential lease for this grant and forwarded the request. Do not diagnose this as a missing user token or a local Junior runtime block; diagnose provider-side permissions, installation scope, SSO, or actor-provider account access.",
+    ...stderr ? ["", `stderr:
+${stderr}`] : [],
+    ...stdout ? ["", `stdout:
+${stdout}`] : []
+  ].join("\n");
+}
+function normalizeDetails(details, options) {
+  const continuationToolName = options.toolName && hasContinuation(details) ? options.toolName : void 0;
+  if (!continuationToolName) {
+    return { details, replaceEnvelopeText: false };
+  }
+  return {
+    details: injectContinuationToolName(details, continuationToolName),
+    replaceEnvelopeText: true
+  };
+}
+function normalizeToolResult(result, options = {}) {
+  const unwrapped = result;
+  if (isStructuredToolExecutionResult(unwrapped)) {
+    const normalized2 = normalizeDetails(unwrapped.details, options);
+    const permissionText = upstreamPermissionDeniedText(normalized2.details);
+    if (!permissionText && normalized2.details === unwrapped.details) {
+      return unwrapped;
+    }
+    const content = permissionText || normalized2.replaceEnvelopeText ? replaceGeneratedTextContent(
+      unwrapped.content,
+      permissionText ?? toToolContentText(normalized2.details)
+    ) : unwrapped.content;
+    return {
+      content,
+      details: normalized2.details
+    };
+  }
+  if (isContentOnlyToolExecutionResult(unwrapped)) {
+    if (options.requireStructuredResult) {
+      throw new TypeError(
+        "Structured tools must return details matching their outputSchema."
+      );
+    }
+    return {
+      content: unwrapped.content,
+      details: {}
+    };
+  }
+  const normalized = normalizeDetails(unwrapped, options);
+  return {
+    content: [
+      {
+        type: "text",
+        text: upstreamPermissionDeniedText(normalized.details) ?? toToolContentText(normalized.details)
+      }
+    ],
+    details: normalized.details
+  };
+}
+
+// src/chat/agent/sandbox.ts
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function textContent(value) {
+  return Array.isArray(value) ? value.flatMap((part) => {
+    const item = record(part);
+    return item.type === "text" && typeof item.text === "string" ? [item.text] : [];
+  }).join("\n") : "";
+}
+function createPluginToolSandbox(sandbox, options) {
+  return {
+    root: SANDBOX_WORKSPACE_ROOT,
+    juniorRoot: `${SANDBOX_WORKSPACE_ROOT}/.junior`,
+    async readFile(filePath) {
+      return await sandbox.workspace.readFileToBuffer({ path: filePath }) ?? null;
+    },
+    async run(input) {
+      input.signal?.throwIfAborted();
+      const result = await sandbox.tools.execute({
+        toolName: "bash",
+        input: {
+          command: `${input.sudo ? "sudo -- " : ""}${buildCommandScript(input)}`,
+          ...input.cwd ? { cwd: input.cwd } : {},
+          ...input.env ? { env: input.env } : {}
+        },
+        ...input.signal ? { signal: input.signal } : {}
+      });
+      const normalized = normalizeToolResult(result, { toolName: "bash" });
+      await options.handleAuthSignal(normalized.details);
+      input.signal?.throwIfAborted();
+      const details = record(normalized.details);
+      return {
+        exitCode: typeof details.exit_code === "number" ? details.exit_code : 1,
+        stdout: typeof details.stdout === "string" ? details.stdout : "",
+        stderr: details.permission_denied !== void 0 ? textContent(normalized.content) : typeof details.stderr === "string" ? details.stderr : ""
+      };
+    },
+    async writeFile(input) {
+      await sandbox.workspace.writeFiles([
+        {
+          path: input.path,
+          content: input.content,
+          ...input.mode !== void 0 ? { mode: input.mode } : {}
+        }
+      ]);
+    }
+  };
+}
+function bashCommand(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return void 0;
+  }
+  const command = input.command;
+  return typeof command === "string" && command.trim() ? command.trim() : void 0;
+}
+function createAgentSandbox(options) {
+  const sandbox = createSandbox({
+    sandboxRef: options.sandboxRef,
+    skills: options.skills,
+    referenceFiles: listReferenceFiles(),
+    traceContext: options.traceContext,
+    tracePropagation: options.tracePropagation,
+    egressSignals: options.egressSignals,
+    credentialEgress: options.credentialEgress,
+    prepare: options.prepareSandbox,
+    onSandboxRefChanged: async (sandboxRef) => {
+      options.onSandboxRefChanged(sandboxRef);
+      await options.persistSandboxRef?.(sandboxRef);
+    }
+  });
+  return {
+    captureRepositoryInstructions: sandbox.captureRepositoryInstructions,
+    workspace: sandbox.workspace,
+    sandboxRef: sandbox.sandboxRef,
+    close: sandbox.close,
+    tools: {
+      supports: sandbox.tools.supports,
+      async execute(params) {
+        const command = params.toolName === "bash" ? bashCommand(params.input) : void 0;
+        if (command) {
+          const result = await maybeExecuteJrRpcCustomCommand(command, {
+            activeSkill: options.getActiveSkill(),
+            channelConfiguration: options.channelConfiguration,
+            actorId: isUserActor(options.actor) ? options.actor.userId : void 0,
+            onConfigurationValueChanged: (key, value) => {
+              if (value === void 0) {
+                delete options.configurationValues[key];
+                return;
+              }
+              options.configurationValues[key] = value;
+            }
+          });
+          if (result.handled) {
+            return formatSandboxCommandResult(result.result);
+          }
+        }
+        return await sandbox.tools.execute(params);
+      }
+    },
+    async writeGeneratedArtifacts(files) {
+      return await writeSandboxGeneratedArtifacts(sandbox.workspace, files);
+    }
+  };
+}
+
+// src/chat/mcp/tool-manager.ts
+import {
+  missingToolAnnotationKeys
+} from "@sentry/junior-plugin-api";
+
+// src/chat/mcp/client.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { Client } from "@modelcontextprotocol/sdk/client";
+import {
+  UnauthorizedError
+} from "@modelcontextprotocol/sdk/client/auth.js";
+import {
+  StreamableHTTPClientTransport,
+  StreamableHTTPError
+} from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+var MCP_CLIENT_INFO = {
+  name: "junior-mcp-client",
+  version: "1.0.0"
+};
+var MCP_TOOLS_CALL_METHOD = "tools/call";
+function getDefaultPort(url) {
+  if (url.protocol === "https:") {
+    return 443;
+  }
+  if (url.protocol === "http:") {
+    return 80;
+  }
+  return void 0;
+}
+function getMcpNetworkAttributes(url) {
+  const port = url.port ? Number(url.port) : getDefaultPort(url);
   return {
     "server.address": url.hostname,
     ...port !== void 0 ? { "server.port": port } : {},
@@ -6762,6 +6914,7 @@ function createBashTool() {
     description: "Run a bash command inside the isolated sandbox workspace. Use this for repository inspection/execution tasks that need shell access. Do not use for network-sensitive or destructive actions unless explicitly required.",
     inputSchema: z10.object({
       command: z10.string().min(1).describe("Bash command to run inside the sandbox."),
+      cwd: z10.string().min(1).describe("Optional working directory for this command only.").optional(),
       timeoutMs: z10.coerce.number().int().min(1e3).describe(
         "Optional command timeout in milliseconds. Use for commands that may hang."
       ).optional()
@@ -7355,13 +7508,13 @@ function createViewImageTool(sandbox, supportsImageInput, deps = {}) {
     description: "View an image file from the sandbox workspace when visual inspection is needed. Supports PNG, JPEG, GIF, and WebP images up to 5 MB.",
     exposure: "direct",
     inputSchema: viewImageInputSchema,
-    async execute({ path: path9 }) {
+    async execute({ path: path8 }) {
       if (!supportsImageInput()) {
         throw new ToolInputError(
           "viewImage is unavailable because the current model does not support image inputs"
         );
       }
-      const targetPath = normalizeSandboxPath(path9);
+      const targetPath = normalizeSandboxPath(path8);
       const data = deps.readFile ? await deps.readFile(targetPath) : await sandbox.readFileToBuffer({ path: targetPath });
       if (!data) {
         throw new SandboxFileNotFoundError(targetPath);
@@ -7618,8 +7771,8 @@ async function indexTtlMs(state, subscriptionIds, nowMs) {
   const latestExpiresAtMs = Math.max(
     nowMs,
     ...records.filter(
-      (record) => record !== void 0 && activeAt(record, nowMs)
-    ).map((record) => record.expiresAtMs)
+      (record2) => record2 !== void 0 && activeAt(record2, nowMs)
+    ).map((record2) => record2.expiresAtMs)
   );
   return ttlUntil(latestExpiresAtMs, nowMs);
 }
@@ -7655,7 +7808,7 @@ async function createResourceEventSubscription(input, options = {}) {
     identifier: input.identifier,
     teamId: subscriptionTeamId(input.destination)
   });
-  const record = {
+  const record2 = {
     conversationId: input.conversationId,
     createdAtMs: nowMs,
     destination: input.destination,
@@ -7670,7 +7823,7 @@ async function createResourceEventSubscription(input, options = {}) {
     status: "active",
     updatedAtMs: nowMs
   };
-  const parsed = subscriptionSchema.parse(record);
+  const parsed = subscriptionSchema.parse(record2);
   await state.set(
     subscriptionKey(id),
     parsed,
@@ -7708,7 +7861,7 @@ async function listResourceEventSubscriptions(input) {
     )
   );
   return records.filter(
-    (record) => record !== void 0 && record.conversationId === input.conversationId && activeAt(record, nowMs)
+    (record2) => record2 !== void 0 && record2.conversationId === input.conversationId && activeAt(record2, nowMs)
   ).sort((left, right) => left.createdAtMs - right.createdAtMs);
 }
 async function cancelResourceEventSubscription(input) {
@@ -7776,7 +7929,7 @@ async function findMatchingResourceEventSubscriptions(input) {
     )
   );
   return records.filter(
-    (record) => record !== void 0 && matchesEvent(record, {
+    (record2) => record2 !== void 0 && matchesEvent(record2, {
       eventType: input.eventType,
       nowMs,
       namespace: input.namespace,
@@ -11192,8 +11345,8 @@ function normalizeUser(raw) {
     display_name: raw.profile?.display_name || void 0,
     title: raw.profile?.title || void 0,
     email: raw.profile?.email || void 0,
-    status_text: raw.profile?.status_text || void 0,
-    status_emoji: raw.profile?.status_emoji || void 0,
+    status_text: raw.profile?.status_text ?? void 0,
+    status_emoji: raw.profile?.status_emoji ?? void 0,
     is_bot: raw.is_bot ?? false,
     is_deleted: raw.deleted ?? false,
     timezone: raw.tz || void 0,
@@ -11310,10 +11463,6 @@ async function searchSlackUsers(options) {
 
 // src/chat/slack/tools/user-lookup.ts
 import { z as z49 } from "zod";
-var booleanInput4 = (description) => z49.preprocess(
-  (value) => value === "true" ? true : value === "false" ? false : value,
-  z49.boolean()
-).describe(description);
 function explicitUserLookupError(error) {
   if (error.apiError === "user_not_found") {
     return "No Slack user found for the supplied user ID.";
@@ -11334,7 +11483,7 @@ function explicitUserLookupError(error) {
 }
 function createSlackUserLookupTool() {
   return zodTool({
-    description: "Look up Slack user profiles by user ID, email, or name search. Use when you need to identify a user, resolve cross-platform identity, or look up profile details like title or status. Returns profile fields including custom fields. For user ID lookup, pass a Slack user ID (e.g. U039RR91S). For search, pass a name query.",
+    description: "Look up Slack user profiles by user ID, email, or name search. Set mode to match the identifier in value. Returns profile fields including title, status, and custom fields.",
     annotations: {
       destructiveHint: false,
       idempotentHint: true,
@@ -11342,51 +11491,18 @@ function createSlackUserLookupTool() {
       readOnlyHint: true
     },
     inputSchema: z49.object({
-      user_id: slackUserIdParam(
-        "Slack user ID to look up (e.g. U039RR91S). Mutually exclusive with email and query."
-      ).optional(),
-      email: z49.string().min(3).describe(
-        "Email address to look up. Mutually exclusive with user_id and query."
-      ).optional(),
-      query: z49.string().min(2).describe(
-        "Name to search for (matches against username, display name, real name). Mutually exclusive with user_id and email."
-      ).optional(),
-      limit: z49.coerce.number().int().min(1).max(20).describe(
-        "Maximum number of results to return for name search. Defaults to 10."
-      ).optional(),
-      max_pages: z49.coerce.number().int().min(1).max(5).describe(
-        "Maximum number of Slack API pages to scan for name search. Defaults to 3."
-      ).optional(),
-      include_bots: booleanInput4(
-        "Include bot accounts in name search results. Defaults to false."
-      ).optional()
-    }),
+      mode: z49.enum(["user_id", "email", "query"]).describe(
+        "Lookup method: user_id for Slack IDs, email for email addresses, or query for name searches."
+      ),
+      value: z49.string().trim().min(2).describe(
+        "The Slack user ID, email address, or name to look up, interpreted according to mode."
+      )
+    }).strict(),
     outputSchema: juniorToolOutputSchema,
-    execute: async ({
-      user_id,
-      email,
-      query,
-      limit,
-      max_pages,
-      include_bots
-    }) => {
-      const modes = [user_id, email, query].filter(Boolean);
-      if (modes.length === 0) {
-        throw new ToolInputError(
-          "Provide exactly one of user_id, email, or query to look up a Slack user."
-        );
-      }
-      if (modes.length > 1) {
-        throw new ToolInputError(
-          "Only one of user_id, email, or query can be provided."
-        );
-      }
+    execute: async ({ mode, value }) => {
       try {
-        if (user_id) {
-          const parsedUserId = parseRequiredSlackUserIdParam(
-            "user_id",
-            user_id
-          );
+        if (mode === "user_id") {
+          const parsedUserId = parseRequiredSlackUserIdParam("value", value);
           if (!parsedUserId.ok) {
             throw new ToolInputError(parsedUserId.error);
           }
@@ -11395,11 +11511,11 @@ function createSlackUserLookupTool() {
             user: await lookupSlackUserProfile(parsedUserId.value)
           };
         }
-        if (email) {
-          const profile = await lookupSlackUserByEmail(email);
+        if (mode === "email") {
+          const profile = await lookupSlackUserByEmail(value);
           if (!profile) {
             throw new ToolInputError(
-              `No Slack user found with email address ${email}.`
+              `No Slack user found with email address ${value}.`
             );
           }
           return {
@@ -11408,14 +11524,14 @@ function createSlackUserLookupTool() {
           };
         }
         const result = await searchSlackUsers({
-          query,
-          limit: limit ?? 10,
-          maxPages: max_pages ?? 3,
-          includeBots: include_bots ?? false
+          query: value,
+          limit: 10,
+          maxPages: 3,
+          includeBots: false
         });
         return {
           mode: "query",
-          query,
+          query: value,
           count: result.users.length,
           searched_pages: result.searched_pages,
           searched_user_count: result.searched_user_count,
@@ -11437,43 +11553,94 @@ function createSlackUserLookupTool() {
 
 // src/chat/tools/system-time.ts
 import { z as z50 } from "zod";
+var systemTimeInputSchema = z50.object({
+  timezone: z50.string().trim().min(1).optional().describe(
+    "Optional IANA timezone, for example America/Los_Angeles. When set, iso_local and timezone_offset_minutes are for that zone."
+  )
+});
 var systemTimeOutputSchema = juniorToolOutputSchema.extend({
   unix_ms: z50.number(),
   iso_utc: z50.string(),
   iso_local: z50.string(),
+  timezone: z50.string().nullable(),
   timezone_offset_minutes: z50.number()
 });
 function createSystemTimeTool() {
   return zodTool({
-    description: "Return current system time in UTC and local ISO formats. Use when the user asks for current time/date context. Do not use as a substitute for historical or timezone-conversion research.",
+    description: "Return current system time in UTC and optional local IANA timezone formats. Use when the user asks for current time/date context. Pass timezone when the answer should be in a known IANA zone such as America/Los_Angeles.",
     annotations: {
       destructiveHint: false,
       idempotentHint: true,
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z50.object({}),
+    inputSchema: systemTimeInputSchema,
     outputSchema: systemTimeOutputSchema,
     privateTraceResult: (result) => ({
       unix_ms: result.unix_ms,
       iso_utc: result.iso_utc,
       iso_local: result.iso_local,
+      timezone: result.timezone,
       timezone_offset_minutes: result.timezone_offset_minutes
     }),
-    execute: async () => {
+    execute: async (input) => {
       const now = /* @__PURE__ */ new Date();
-      const details = {
+      const timezone = input.timezone?.trim() || null;
+      if (timezone) {
+        if (!isValidTimeZone2(timezone)) {
+          throw new Error("timezone must be a valid IANA time zone.");
+        }
+        const parts = getZonedDateTimeParts(now.getTime(), timezone);
+        const isoLocal = [
+          String(parts.year).padStart(4, "0"),
+          String(parts.month).padStart(2, "0"),
+          String(parts.day).padStart(2, "0")
+        ].join("-") + "T" + [
+          String(parts.hour).padStart(2, "0"),
+          String(parts.minute).padStart(2, "0"),
+          String(parts.second).padStart(2, "0")
+        ].join(":");
+        return {
+          unix_ms: now.getTime(),
+          iso_utc: now.toISOString(),
+          iso_local: isoLocal,
+          timezone,
+          timezone_offset_minutes: getTimeZoneOffsetMinutes(
+            now.getTime(),
+            timezone
+          )
+        };
+      }
+      return {
         unix_ms: now.getTime(),
         iso_utc: now.toISOString(),
         iso_local: new Date(now.getTime() - now.getTimezoneOffset() * 6e4).toISOString().replace("Z", ""),
+        timezone: null,
         timezone_offset_minutes: now.getTimezoneOffset()
       };
-      return {
-        ...details
-      };
     }
   });
 }
+function isValidTimeZone2(timezone) {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: timezone }).format();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getTimeZoneOffsetMinutes(timestampMs, timezone) {
+  const parts = getZonedDateTimeParts(timestampMs, timezone);
+  const asUtcMs = Date.UTC(
+    parts.year,
+    parts.month - 1,
+    parts.day,
+    parts.hour,
+    parts.minute,
+    parts.second
+  );
+  return Math.round((timestampMs - asUtcMs) / 6e4);
+}
 
 // src/chat/tools/query-conversation-events.ts
 import { z as z51 } from "zod";
@@ -11894,16 +12061,16 @@ async function resolvePublicHostname(hostname) {
     throw new Error("Could not resolve hostname");
   }
   const deduped = /* @__PURE__ */ new Map();
-  for (const record of records) {
-    const family = record.family === 6 ? 6 : 4;
-    if (family === 4 && isPrivateIpv4(record.address)) {
+  for (const record2 of records) {
+    const family = record2.family === 6 ? 6 : 4;
+    if (family === 4 && isPrivateIpv4(record2.address)) {
       throw new Error("Resolved to a private IPv4 address");
     }
-    if (family === 6 && isPrivateIpv6(record.address)) {
+    if (family === 6 && isPrivateIpv6(record2.address)) {
       throw new Error("Resolved to a private IPv6 address");
     }
-    deduped.set(`${family}:${record.address}`, {
-      address: record.address,
+    deduped.set(`${family}:${record2.address}`, {
+      address: record2.address,
       family
     });
   }
@@ -12564,7 +12731,9 @@ function createTools(availableSkills, hooks = {}, context, options = {}) {
       );
     }
   }
-  for (const [name, pluginTool] of Object.entries(getPluginTools(context))) {
+  for (const [name, pluginTool] of Object.entries(
+    getPluginTools(context, options.pluginSandbox)
+  )) {
     if (tools[name]) {
       throw new Error(`Plugin tool "${name}" conflicts with a core tool`);
     }
@@ -12684,6 +12853,7 @@ function buildSandboxInput(toolName, params) {
   if (toolName === "bash") {
     return {
       command: String(params.command ?? ""),
+      ...typeof params.cwd === "string" ? { cwd: params.cwd } : {},
       ...params.env && typeof params.env === "object" && !Array.isArray(params.env) ? { env: params.env } : {},
       ...optionalNumber(params.timeoutMs) ? { timeoutMs: optionalNumber(params.timeoutMs) } : {}
     };
@@ -12734,184 +12904,6 @@ function buildSandboxInput(toolName, params) {
   return params;
 }
 
-// src/chat/tool-support/normalize-result.ts
-function isToolContent(value) {
-  return Array.isArray(value) && value.every((part) => {
-    if (!part || typeof part !== "object") {
-      return false;
-    }
-    const record = part;
-    if (record.type === "text") {
-      return typeof record.text === "string";
-    }
-    if (record.type === "image") {
-      return typeof record.data === "string" && typeof record.mimeType === "string";
-    }
-    return false;
-  });
-}
-function isStructuredToolExecutionResult(value) {
-  const content = value?.content;
-  return typeof value === "object" && value !== null && isToolContent(content) && "details" in value;
-}
-function isContentOnlyToolExecutionResult(value) {
-  const content = value?.content;
-  return typeof value === "object" && value !== null && isToolContent(content) && !("details" in value);
-}
-function toToolContentText(value) {
-  if (typeof value === "string") return value;
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-}
-function withoutFirstGeneratedTextContent(content) {
-  const [first, ...rest] = content;
-  if (first?.type === "text") {
-    return rest;
-  }
-  return content;
-}
-function replaceGeneratedTextContent(content, text) {
-  return [
-    {
-      type: "text",
-      text
-    },
-    ...withoutFirstGeneratedTextContent(content)
-  ];
-}
-function isRecord3(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function hasContinuation(value) {
-  return isRecord3(value) && isRecord3(value.continuation);
-}
-function stringField(record, key) {
-  const value = record[key];
-  return typeof value === "string" ? value : "";
-}
-function numberField(record, key) {
-  const value = record[key];
-  return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
-function stringListField(record, key) {
-  const value = record[key];
-  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
-}
-function accountText(value) {
-  if (!isRecord3(value)) {
-    return void 0;
-  }
-  const label = stringField(value, "label") || stringField(value, "id");
-  const id = stringField(value, "id");
-  if (!label) {
-    return void 0;
-  }
-  return id && id !== label ? `${label} (${id})` : label;
-}
-function upstreamPermissionDeniedText(value) {
-  if (!isRecord3(value) || !isRecord3(value.permission_denied)) {
-    return void 0;
-  }
-  const signal = value.permission_denied;
-  if (signal.source !== "upstream") {
-    return void 0;
-  }
-  const provider = stringField(signal, "provider");
-  const message = stringField(signal, "message");
-  const upstreamHost = stringField(signal, "upstreamHost");
-  const upstreamPath = stringField(signal, "upstreamPath");
-  const status = numberField(signal, "status");
-  if (!provider || !message || !upstreamHost || !upstreamPath || !status) {
-    return void 0;
-  }
-  const grant = isRecord3(signal.grant) ? signal.grant : {};
-  const grantName = stringField(grant, "name");
-  const grantAccess = stringField(grant, "access");
-  const grantReason = stringField(grant, "reason");
-  const grantRequirements = stringListField(grant, "requirements");
-  const account = accountText(signal.account);
-  const command = stringField(value, "command");
-  const stderr = stringField(value, "stderr").trim();
-  const stdout = stringField(value, "stdout").trim();
-  const acceptedPermissions = stringField(signal, "acceptedPermissions");
-  const sso = stringField(signal, "sso");
-  return [
-    "Upstream permission denied.",
-    message,
-    "",
-    `Provider: ${provider}`,
-    ...account ? [`Provider account: ${account}`] : [],
-    `Grant: ${grantName || "unknown"}${grantAccess ? ` (${grantAccess}${grantReason ? `, ${grantReason}` : ""})` : ""}`,
-    ...grantRequirements.length > 0 ? [
-      "Provider requirements:",
-      ...grantRequirements.map((item) => `- ${item}`)
-    ] : [],
-    `Upstream: ${upstreamHost}${upstreamPath}`,
-    `Status: ${status}`,
-    ...acceptedPermissions ? [`Accepted provider permissions: ${acceptedPermissions}`] : [],
-    ...sso ? [`Provider SSO: ${sso}`] : [],
-    ...command ? [`Command: ${command}`] : [],
-    "",
-    "Junior had a credential lease for this grant and forwarded the request. Do not diagnose this as a missing user token or a local Junior runtime block; diagnose provider-side permissions, installation scope, SSO, or actor-provider account access.",
-    ...stderr ? ["", `stderr:
-${stderr}`] : [],
-    ...stdout ? ["", `stdout:
-${stdout}`] : []
-  ].join("\n");
-}
-function normalizeDetails(details, options) {
-  const continuationToolName = options.toolName && hasContinuation(details) ? options.toolName : void 0;
-  if (!continuationToolName) {
-    return { details, replaceEnvelopeText: false };
-  }
-  return {
-    details: injectContinuationToolName(details, continuationToolName),
-    replaceEnvelopeText: true
-  };
-}
-function normalizeToolResult(result, options = {}) {
-  const unwrapped = result;
-  if (isStructuredToolExecutionResult(unwrapped)) {
-    const normalized2 = normalizeDetails(unwrapped.details, options);
-    const permissionText = upstreamPermissionDeniedText(normalized2.details);
-    if (!permissionText && normalized2.details === unwrapped.details) {
-      return unwrapped;
-    }
-    const content = permissionText || normalized2.replaceEnvelopeText ? replaceGeneratedTextContent(
-      unwrapped.content,
-      permissionText ?? toToolContentText(normalized2.details)
-    ) : unwrapped.content;
-    return {
-      content,
-      details: normalized2.details
-    };
-  }
-  if (isContentOnlyToolExecutionResult(unwrapped)) {
-    if (options.requireStructuredResult) {
-      throw new TypeError(
-        "Structured tools must return details matching their outputSchema."
-      );
-    }
-    return {
-      content: unwrapped.content,
-      details: {}
-    };
-  }
-  const normalized = normalizeDetails(unwrapped, options);
-  return {
-    content: [
-      {
-        type: "text",
-        text: upstreamPermissionDeniedText(normalized.details) ?? toToolContentText(normalized.details)
-      }
-    ],
-    details: normalized.details
-  };
-}
-
 // src/chat/tools/execution/tool-error-handler.ts
 import { PluginToolInputError } from "@sentry/junior-plugin-api";
 
@@ -15082,8 +15074,8 @@ function contentText(content) {
     if (!part || typeof part !== "object") {
       return [];
     }
-    const record = part;
-    return typeof record.text === "string" ? [record.text] : [];
+    const record2 = part;
+    return typeof record2.text === "string" ? [record2.text] : [];
   }).join("\n");
 }
 function assistantEntries(message) {
@@ -15103,13 +15095,13 @@ function assistantEntries(message) {
     if (!part || typeof part !== "object") {
       continue;
     }
-    const record = part;
-    if (record.type !== "toolCall" || typeof record.name !== "string" || !record.name) {
+    const record2 = part;
+    if (record2.type !== "toolCall" || typeof record2.name !== "string" || !record2.name) {
       continue;
     }
-    const toolInput = serializedText(record.arguments);
+    const toolInput = serializedText(record2.arguments);
     if (toolInput.trim()) {
-      entries.push({ role: `tool ${record.name} call`, text: toolInput });
+      entries.push({ role: `tool ${record2.name} call`, text: toolInput });
     }
   }
   return entries;
@@ -15434,7 +15426,12 @@ async function wireAgentTools(args) {
       }
     },
     toolRuntimeContext,
-    { includeLoadSkill: !explicitSkillLoaded }
+    {
+      includeLoadSkill: !explicitSkillLoaded,
+      pluginSandbox: createPluginToolSandbox(agentSandbox, {
+        handleAuthSignal: pluginAuth.maybeHandleAuthSignal
+      })
+    }
   );
   const plannedToolExposure = planToolExposure(
     tools
@@ -15509,6 +15506,7 @@ async function wireAgentTools(args) {
       return actionReview.projectToolResult(toolCallId, result);
     },
     getSandboxRef: agentSandbox.sandboxRef,
+    captureRepositoryInstructions: agentSandbox.captureRepositoryInstructions,
     async close() {
       agentSandbox.close();
       try {
@@ -15799,6 +15797,59 @@ function userMessage(text) {
     timestamp: Date.now()
   };
 }
+function userMessageContent(message) {
+  const content = message.content;
+  return Array.isArray(content) ? content : [];
+}
+function hasTurnBootstrap(message) {
+  return userMessageContent(message).some(
+    (part) => textPart(part)?.startsWith(`<${TURN_CONTEXT_TAG}>`) === true
+  );
+}
+function effectiveRuntimeContext(messages) {
+  let latestBootstrapIndex = -1;
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (hasTurnBootstrap(messages[index])) {
+      latestBootstrapIndex = index;
+      break;
+    }
+  }
+  const effectiveMessages = latestBootstrapIndex < 0 ? messages : messages.slice(latestBootstrapIndex);
+  const allContent = effectiveMessages.flatMap(userMessageContent);
+  const firstAgentsIndex = allContent.findIndex(
+    (part) => textPart(part)?.startsWith("# AGENTS.md instructions") === true
+  );
+  const content = allContent.filter(
+    (part) => textPart(part)?.startsWith("# AGENTS.md instructions") !== true
+  );
+  const visibleAgents = findVisibleAgentsInstructions(effectiveMessages);
+  if (visibleAgents?.active === true) {
+    const insertionIndex = firstAgentsIndex < 0 ? content.length : Math.min(firstAgentsIndex, content.length);
+    content.splice(insertionIndex, 0, {
+      type: "text",
+      text: renderAgentsInstructions({
+        directory: visibleAgents.directory,
+        text: visibleAgents.text
+      })
+    });
+  }
+  const latestTimestamp = effectiveMessages.at(-1)?.timestamp;
+  return {
+    content,
+    timestamp: typeof latestTimestamp === "number" ? latestTimestamp : Date.now()
+  };
+}
+function runtimeContextMessage(messages, timestamp) {
+  const runtimeContext = effectiveRuntimeContext(messages);
+  if (runtimeContext.content.length === 0) {
+    return void 0;
+  }
+  return {
+    role: "user",
+    content: runtimeContext.content,
+    timestamp: timestamp ?? runtimeContext.timestamp
+  };
+}
 function selectRetainedUserMessageEntries(messages, maxTokens = RETAINED_USER_MESSAGE_TOKENS) {
   const selected = [];
   let remaining = maxTokens;
@@ -16062,21 +16113,19 @@ function createContextCompactor(deps) {
   };
 }
 async function compactContextForHandoff(args, deps) {
-  const runtimeMessage = args.runtimeContext.at(-1);
-  if (!runtimeMessage) {
+  const contextMessage = runtimeContextMessage(args.runtimeContext);
+  if (!contextMessage) {
     throw new Error("Handoff requires the current runtime turn context");
   }
   const generatedSummary = await summarizeContext(args, deps);
   const summary = `${MODEL_HANDOFF_SUMMARY_PREFIX}
 ${generatedSummary}`;
-  const message = {
-    ...runtimeMessage,
-    content: [
-      ...runtimeMessage.content,
-      { type: "text", text: renderCurrentInstruction(summary) }
-    ]
+  const instructionMessage = {
+    role: "user",
+    content: [{ type: "text", text: renderCurrentInstruction(summary) }],
+    timestamp: contextMessage.timestamp
   };
-  const messages = [message];
+  const messages = [contextMessage, instructionMessage];
   const replacementMessages = stripRuntimeTurnContext(messages);
   args.signal?.throwIfAborted();
   await getConversationEventStore().replaceHistory(args.conversationId, {
@@ -16138,10 +16187,18 @@ async function compactActiveContextIfNeeded(args, deps) {
     `${ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX}
 ${summary}`
   );
-  const runtimeMessages = retainRuntimeTurnContext(args.piMessages);
   const retainedInstruction = pendingMessages.length === 0 ? await loadLastInstruction(args.conversationId) : void 0;
   const instructionMessages = retainedInstruction ? [retainedInstruction.message] : pendingMessages.map((entry) => entry.message);
   const instructionProvenance = retainedInstruction ? [retainedInstruction.provenance] : pendingMessages.map((entry) => entry.provenance);
+  const instructionTimestamp = instructionMessages[0]?.timestamp;
+  const retainedRuntimeContext = retainRuntimeTurnContext(
+    args.runtimeContextMessages ?? args.piMessages
+  );
+  const contextMessage = runtimeContextMessage(
+    retainedRuntimeContext,
+    typeof instructionTimestamp === "number" ? instructionTimestamp : void 0
+  );
+  const runtimeMessages = contextMessage ? [contextMessage] : [];
   const messages = [...runtimeMessages, ...instructionMessages, summaryMessage];
   const replacementInputTokens = estimateHistoryTokens(messages);
   if (replacementInputTokens >= inputLimitTokens) {
@@ -16447,7 +16504,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       syncLoadedSkillNamesForResume
     });
     const explicitSkill = invokedSkill ? activeSkills.find((skill) => skill.name === invokedSkill.name) ?? null : null;
-    const { routerBlocks, userContentParts } = buildPromptInput(input);
+    const { contextContentParts, routerBlocks, userContentParts } = buildPromptInput(input);
     const preAgentPromptMessages = () => existingSessionRecord?.piMessages ?? [...input.piMessages ?? []];
     const storedTurnRoute = await loadTurnRoute({ conversationId, turnId });
     if (storedTurnRoute) {
@@ -16667,6 +16724,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
     });
     mcpToolManager = wiring.mcpToolManager;
     closeTools = wiring.close;
+    const initialRepositoryInstructions = wiring.getSandboxRef() ? await wiring.captureRepositoryInstructions() : void 0;
     const getPendingAuthPause = wiring.getPendingAuthPause;
     const toolsWithoutHandoff = wiring.agentTools.filter(
       (tool) => tool.name !== HANDOFF_TOOL_NAME
@@ -16694,18 +16752,29 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
     };
     const {
       baseInstructions,
+      contextContentParts: promptContextContentParts,
       inputMessages,
       inputMessagesAttribute,
-      promptContentParts,
+      promptTimestamp: restoredPromptTimestamp,
       promptHistoryMessages,
       shouldPromptAgent,
-      turnContexts
+      turnContexts,
+      userContentParts: promptUserContentParts
     } = await assemblePrompt({
       activeMcpCatalogs: wiring.activeMcpCatalogs,
       currentActor: actor,
       artifactState: state.artifactState,
       availableSkills,
       configurationValues,
+      contextContentParts: [
+        ...initialRepositoryInstructions ? [
+          {
+            type: "text",
+            text: renderAgentsInstructions(initialRepositoryInstructions)
+          }
+        ] : [],
+        ...contextContentParts
+      ],
       conversationPrivacy,
       existingSessionPiMessages: existingSessionRecord?.piMessages,
       existingTurnStartMessageIndex: existingSessionRecord?.turnStartMessageIndex,
@@ -16719,6 +16788,18 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       toolRuntimeContext: wiring.toolRuntimeContext,
       userContentParts
     });
+    const repositoryInstructionsContext = createRepositoryInstructionsContext({
+      capture: wiring.captureRepositoryInstructions,
+      hasSandbox: () => Boolean(wiring.getSandboxRef()),
+      initialInstructions: initialRepositoryInstructions,
+      promptContextContentParts,
+      restoredMessages: existingSessionRecord?.piMessages,
+      restoredProvenance: existingSessionRecord?.piMessageProvenance,
+      setMessages(messages) {
+        agent.state.messages = messages;
+      },
+      shouldPromptAgent
+    });
     runResume.setTurnContexts(turnContexts);
     const applyPendingHandoff = () => {
       if (!pendingHandoff) {
@@ -16750,7 +16831,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
         thinkingLevel
       };
     };
-    const applyActiveContextCompaction = async (messages, hookSignal, pendingMessages, clearSteeringQueueOnCommit = false) => {
+    const applyActiveContextCompaction = async (messages, hookSignal, pendingMessages, clearSteeringQueueOnCommit = false, pairPendingRuntimeContext = false) => {
       const compaction = await compactActiveContextIfNeeded(
         {
           conversationContext: input.conversationContext,
@@ -16766,6 +16847,12 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
           onCompactionStart: () => observers.onStatus?.({ text: "Compacting context" }),
           pendingMessages,
           piMessages: messages,
+          ...pairPendingRuntimeContext && pendingMessages ? {
+            runtimeContextMessages: [
+              ...messages,
+              ...pendingMessages.map((entry) => entry.message)
+            ]
+          } : {},
           signal: hookSignal
         },
         {
@@ -16903,13 +16990,18 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
             pendingMessages,
             true
           );
+          const combinedUpdate = capacityUpdate && handoffUpdate ? { ...handoffUpdate, ...capacityUpdate } : capacityUpdate ?? handoffUpdate;
+          const repositoryInstructionsUpdate = await repositoryInstructionsContext.applyUpdate(
+            combinedUpdate,
+            nextTurn.context
+          );
           const yieldError = runResume.prepareYieldIfDue(
             currentAgentMessages()
           );
           if (yieldError) {
             throw yieldError;
           }
-          return capacityUpdate && handoffUpdate ? { ...handoffUpdate, ...capacityUpdate } : capacityUpdate ?? handoffUpdate;
+          return repositoryInstructionsUpdate;
         } catch (error) {
           pendingPiHookError ??= error instanceof Error ? error : new Error(String(error));
           throw error;
@@ -16964,20 +17056,37 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
         "gen_ai.invoke_agent",
         spanContext,
         async () => {
+          const promptTimestamp = restoredPromptTimestamp ?? Date.now();
+          const contextMessage = shouldPromptAgent && promptContextContentParts.length > 0 ? {
+            role: "user",
+            content: promptContextContentParts,
+            timestamp: promptTimestamp
+          } : void 0;
           const freshPromptMessage = {
             role: "user",
-            content: promptContentParts,
-            timestamp: Date.now()
+            content: promptUserContentParts,
+            timestamp: promptTimestamp
           };
           if (shouldPromptAgent) {
             const promptPersisted = await runResume.requireDurableInputCheckpoint([
               ...agent.state.messages,
+              ...contextMessage ? [contextMessage] : [],
               freshPromptMessage
             ]);
             if (promptPersisted) {
               await runResume.commitInput();
             }
           }
+          if (contextMessage) {
+            agent.state.messages = [...agent.state.messages, contextMessage];
+          }
+          if (!shouldPromptAgent) {
+            await repositoryInstructionsContext.applyUpdate(void 0, {
+              messages: agent.state.messages,
+              systemPrompt: agent.state.systemPrompt,
+              tools: agent.state.tools
+            });
+          }
           const runAgentStep = async (run2, abortRun = () => agent.abort()) => {
             let timeoutId;
             let removeAbortListener;
@@ -17074,7 +17183,10 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
             await runAgentStep(
               scheduleHandoff({
                 profile: requestedProfile,
-                runtimeContextSourceMessages: shouldPromptAgent ? [freshPromptMessage] : void 0,
+                runtimeContextSourceMessages: shouldPromptAgent ? [
+                  ...contextMessage ? [contextMessage] : [],
+                  freshPromptMessage
+                ] : void 0,
                 signal: handoffAbortController.signal,
                 sourceMessages: [...agent.state.messages]
               }),
@@ -17092,7 +17204,9 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
                   message: freshPromptMessage,
                   provenance: instructionProvenanceFor(actor)
                 }
-              ] : void 0
+              ] : void 0,
+              false,
+              Boolean(contextMessage)
             ),
             () => compactionAbortController.abort()
           );