@sentry/junior 0.45.0 → 0.47.0

package/dist/app.js

@@ -31,7 +31,7 @@ import {
   runNonInteractiveCommand,
   sandboxSkillDir,
   sandboxSkillFile
-} from "./chunk-QAMTCT2R.js";
+} from "./chunk-ELM6HJ6S.js";
 import {
   CredentialUnavailableError,
   buildOAuthTokenRequest,
@@ -2119,6 +2119,10 @@ function markTurnFailed(args) {
 }
 
 // src/chat/runtime/turn-user-message.ts
+function normalizeSlackMessageTs(value) {
+  const trimmed = value?.trim();
+  return trimmed && /^\d+(?:\.\d+)?$/.test(trimmed) ? trimmed : void 0;
+}
 function getTurnUserMessage(conversation, sessionId) {
   for (let index = conversation.messages.length - 1; index >= 0; index -= 1) {
     const message = conversation.messages[index];
@@ -2134,6 +2138,9 @@ function getTurnUserMessage(conversation, sessionId) {
 function getTurnUserMessageId(conversation, sessionId) {
   return getTurnUserMessage(conversation, sessionId)?.id;
 }
+function getTurnUserSlackMessageTs(message) {
+  return normalizeSlackMessageTs(message?.meta?.slackTs) ?? normalizeSlackMessageTs(message?.id);
+}
 function getTurnUserReplyAttachmentContext(message) {
   const inboundAttachmentCount = message?.meta?.attachmentCount ?? 0;
   const imageAttachmentCount = message?.meta?.imageAttachmentCount ?? 0;
@@ -4459,6 +4466,29 @@ function truncateText(value, maxChars = MAX_TEXT_CHARS) {
     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;
+  return {
+    content: [{ type: "text", text: `Path not found: ${textPath}` }],
+    details: {
+      ok: false,
+      error: "not_found",
+      path: params.path,
+      ...params.missingPath ? { missing_path: params.missingPath } : {},
+      truncated: false
+    }
+  };
+}
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -4513,13 +4543,35 @@ function resolveWorkspacePath(input, fallback = ".") {
 async function collectFiles(params) {
   const files = [];
   let limitReached = false;
+  let missingPath;
   const visit = async (dirPath) => {
-    const entries = (await params.fs.readdir(dirPath)).sort(
-      (a, b) => a.toLowerCase().localeCompare(b.toLowerCase())
-    );
+    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);
-      const stat2 = await params.fs.stat(fullPath);
+      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);
@@ -4537,20 +4589,38 @@ async function collectFiles(params) {
       }
     }
   };
-  const stat = await params.fs.stat(params.root);
+  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
+      limitReached: false,
+      missingRoot: false
     };
   }
   await visit(params.root);
-  return { files, limitReached };
+  return {
+    files,
+    limitReached,
+    missingPath,
+    missingRoot: missingPath === params.root
+  };
 }
 
-// src/chat/tools/sandbox/edit-file.ts
-import { Type as Type2 } from "@sinclair/typebox";
+// src/chat/tools/sandbox/text-edits.ts
 function detectLineEnding(value) {
   return value.includes("\r\n") ? "\r\n" : "\n";
 }
@@ -4582,6 +4652,44 @@ function firstChangedLine(oldContent, newContent) {
   }
   return void 0;
 }
+function prepareTextReplacementArguments(input) {
+  if (!input || typeof input !== "object") {
+    return input;
+  }
+  const raw = { ...input };
+  if (typeof raw.edits === "string") {
+    try {
+      raw.edits = JSON.parse(raw.edits);
+    } catch {
+      return raw;
+    }
+  }
+  const edits = Array.isArray(raw.edits) ? [...raw.edits] : [];
+  const oldText = raw.oldText ?? raw.old_text;
+  const newText = raw.newText ?? raw.new_text;
+  if (typeof oldText === "string" && typeof newText === "string") {
+    edits.push({ oldText, newText });
+  }
+  if (edits.length > 0) {
+    raw.edits = edits.map((edit) => {
+      if (!edit || typeof edit !== "object") {
+        return edit;
+      }
+      const record = edit;
+      const { old_text, new_text, ...rest } = record;
+      return {
+        ...rest,
+        oldText: record.oldText ?? old_text,
+        newText: record.newText ?? new_text
+      };
+    });
+  }
+  delete raw.oldText;
+  delete raw.old_text;
+  delete raw.newText;
+  delete raw.new_text;
+  return raw;
+}
 function buildCompactDiff(oldContent, newContent) {
   const oldLines = oldContent.split("\n");
   const newLines = newContent.split("\n");
@@ -4623,19 +4731,19 @@ function buildCompactDiff(oldContent, newContent) {
     firstChangedLine: firstChangedLine(oldContent, newContent)
   };
 }
-function validateAndApplyEdits(content, edits, filePath) {
+function validateAndApplyTextEdits(content, edits, targetName) {
   if (!Array.isArray(edits) || edits.length === 0) {
-    throw new Error("editFile requires at least one edit.");
+    throw new Error(`${targetName} requires at least one edit.`);
   }
   const normalizedEdits = edits.map((edit, index) => {
     if (typeof edit.oldText !== "string" || edit.oldText.length === 0) {
       throw new Error(
-        `edits[${index}].oldText must not be empty in ${filePath}.`
+        `edits[${index}].oldText must not be empty in ${targetName}.`
       );
     }
     if (typeof edit.newText !== "string") {
       throw new Error(
-        `edits[${index}].newText must be a string in ${filePath}.`
+        `edits[${index}].newText must be a string in ${targetName}.`
       );
     }
     return {
@@ -4649,13 +4757,13 @@ function validateAndApplyEdits(content, edits, filePath) {
     const matchIndex = content.indexOf(edit.oldText);
     if (matchIndex === -1) {
       throw new Error(
-        `Could not find edits[${index}] in ${filePath}. oldText must match exactly including whitespace and newlines.`
+        `Could not find edits[${index}] in ${targetName}. oldText must match exactly including whitespace and newlines.`
       );
     }
     const occurrences = countOccurrences(content, edit.oldText);
     if (occurrences > 1) {
       throw new Error(
-        `Found ${occurrences} occurrences of edits[${index}] in ${filePath}. Each oldText must be unique.`
+        `Found ${occurrences} occurrences of edits[${index}] in ${targetName}. Each oldText must be unique.`
       );
     }
     matchedEdits.push({
@@ -4671,7 +4779,7 @@ function validateAndApplyEdits(content, edits, filePath) {
     const current = matchedEdits[index];
     if (previous.matchIndex + previous.matchLength > current.matchIndex) {
       throw new Error(
-        `edits[${previous.editIndex}] and edits[${current.editIndex}] overlap in ${filePath}. Merge overlapping replacements into one edit.`
+        `edits[${previous.editIndex}] and edits[${current.editIndex}] overlap in ${targetName}. Merge overlapping replacements into one edit.`
       );
     }
   }
@@ -4681,47 +4789,15 @@ function validateAndApplyEdits(content, edits, filePath) {
     newContent = newContent.slice(0, edit.matchIndex) + edit.newText + newContent.slice(edit.matchIndex + edit.matchLength);
   }
   if (newContent === content) {
-    throw new Error(`No changes made to ${filePath}.`);
+    throw new Error(`No changes made to ${targetName}.`);
   }
   return { baseContent: content, newContent };
 }
+
+// src/chat/tools/sandbox/edit-file.ts
+import { Type as Type2 } from "@sinclair/typebox";
 function prepareEditFileArguments(input) {
-  if (!input || typeof input !== "object") {
-    return input;
-  }
-  const raw = { ...input };
-  if (typeof raw.edits === "string") {
-    try {
-      raw.edits = JSON.parse(raw.edits);
-    } catch {
-      return raw;
-    }
-  }
-  const edits = Array.isArray(raw.edits) ? [...raw.edits] : [];
-  const oldText = raw.oldText ?? raw.old_text;
-  const newText = raw.newText ?? raw.new_text;
-  if (typeof oldText === "string" && typeof newText === "string") {
-    edits.push({ oldText, newText });
-  }
-  if (edits.length > 0) {
-    raw.edits = edits.map((edit) => {
-      if (!edit || typeof edit !== "object") {
-        return edit;
-      }
-      const record = edit;
-      const { old_text, new_text, ...rest } = record;
-      return {
-        ...rest,
-        oldText: record.oldText ?? old_text,
-        newText: record.newText ?? new_text
-      };
-    });
-  }
-  delete raw.oldText;
-  delete raw.old_text;
-  delete raw.newText;
-  delete raw.new_text;
-  return raw;
+  return prepareTextReplacementArguments(input);
 }
 async function editFile(params) {
   const filePath = resolveWorkspacePath(params.path);
@@ -4729,7 +4805,7 @@ async function editFile(params) {
   const { bom, text } = stripBom(rawContent);
   const lineEnding = detectLineEnding(text);
   const normalizedContent = normalizeToLf(text);
-  const { baseContent, newContent } = validateAndApplyEdits(
+  const { baseContent, newContent } = validateAndApplyTextEdits(
     normalizedContent,
     params.edits,
     params.path
@@ -4810,12 +4886,18 @@ async function findFiles(params) {
   }
   const root = resolveWorkspacePath(params.path);
   const limit = positiveInteger(params.limit) ?? DEFAULT_FIND_LIMIT;
-  const { files, limitReached } = await collectFiles({
+  const { files, limitReached, missingPath, missingRoot } = await collectFiles({
     fs: params.fs,
     root,
     pattern: params.pattern,
     limit
   });
+  if (missingPath) {
+    return missingPathSearchResult({
+      path: params.path ?? ".",
+      ...missingRoot ? { displayPath: params.path ?? "." } : { missingPath }
+    });
+  }
   const relativePaths = files.map(
     (filePath) => path5.posix.relative(root, filePath)
   );
@@ -4912,11 +4994,17 @@ async function grepFiles(params) {
   const limit = positiveInteger(params.limit) ?? DEFAULT_GREP_LIMIT;
   const context = positiveInteger(params.context) ?? 0;
   const regex = params.literal ? void 0 : new RegExp(params.pattern, params.ignoreCase ? "i" : "");
-  const { files } = await collectFiles({
+  const { files, missingPath, missingRoot } = await collectFiles({
     fs: params.fs,
     root,
     pattern: params.glob
   });
+  if (missingPath) {
+    return missingPathSearchResult({
+      path: params.path ?? ".",
+      ...missingRoot ? { displayPath: params.path ?? "." } : { missingPath }
+    });
+  }
   const output = [];
   let matchCount = 0;
   let matchLimitReached = false;
@@ -4926,8 +5014,14 @@ async function grepFiles(params) {
     let content;
     try {
       content = await params.fs.readFile(filePath, { encoding: "utf8" });
-    } catch {
-      continue;
+    } catch (error) {
+      if (isMissingPathError(error)) {
+        return missingPathSearchResult({
+          path: params.path ?? ".",
+          missingPath: filePath
+        });
+      }
+      throw error;
     }
     if (content.includes("\0")) {
       continue;
@@ -5207,13 +5301,29 @@ var DEFAULT_LIST_LIMIT = 500;
 async function listDir(params) {
   const dirPath = resolveWorkspacePath(params.path);
   const limit = positiveInteger(params.limit) ?? DEFAULT_LIST_LIMIT;
-  const stat = await params.fs.stat(dirPath);
+  let stat;
+  try {
+    stat = await params.fs.stat(dirPath);
+  } catch (error) {
+    if (isMissingPathError(error)) {
+      return missingPathSearchResult({ path: params.path ?? "." });
+    }
+    throw error;
+  }
   if (!stat.isDirectory()) {
     throw new Error(`Not a directory: ${params.path ?? "."}`);
   }
-  const entries = (await params.fs.readdir(dirPath)).sort(
-    (a, b) => a.toLowerCase().localeCompare(b.toLowerCase())
-  );
+  let entries;
+  try {
+    entries = (await params.fs.readdir(dirPath)).sort(
+      (a, b) => a.toLowerCase().localeCompare(b.toLowerCase())
+    );
+  } catch (error) {
+    if (isMissingPathError(error)) {
+      return missingPathSearchResult({ path: params.path ?? "." });
+    }
+    throw error;
+  }
   const output = [];
   let entryLimitReached = false;
   for (const entry of entries) {
@@ -5225,8 +5335,14 @@ async function listDir(params) {
     try {
       const entryStat = await params.fs.stat(entryPath);
       output.push(`${entry}${entryStat.isDirectory() ? "/" : ""}`);
-    } catch {
-      continue;
+    } catch (error) {
+      if (isMissingPathError(error)) {
+        return missingPathSearchResult({
+          path: params.path ?? ".",
+          missingPath: entryPath
+        });
+      }
+      throw error;
     }
   }
   const bounded = truncateText(
@@ -5817,6 +5933,14 @@ function sliceFileContent(params) {
     } : {}
   };
 }
+function missingFileResult(path11) {
+  return {
+    content: "",
+    error: "not_found",
+    path: path11,
+    success: false
+  };
+}
 function createReadFileTool() {
   return tool({
     description: "Read a bounded line range from a file in the sandbox workspace. Use when you need exact file contents to verify facts or make edits safely. Prefer grep/findFiles/listDir for broad discovery.",
@@ -6173,6 +6297,37 @@ function createSlackMessageAddReactionTool(context, state) {
 // src/chat/tools/slack/canvas-tools.ts
 import { Type as Type16 } from "@sinclair/typebox";
 
+// src/chat/slack/canvas-references.ts
+var SLACK_FILE_ID_PATTERN = /^F[A-Z0-9]{4,}$/i;
+var SLACK_CANVAS_PATH_PATTERN = /^\/(?:docs|canvas|files)\/(?:T[A-Z0-9]+\/)?(?:U[A-Z0-9]+\/)?(F[A-Z0-9]{4,})(?:\/|$)/i;
+function isSlackHost(hostname) {
+  return hostname === "slack.com" || hostname.endsWith(".slack.com");
+}
+function normalizeReferenceInput(input) {
+  let value = input.trim();
+  if (value.startsWith("<") && value.endsWith(">")) {
+    value = value.slice(1, -1);
+  }
+  return value.split("|", 1)[0]?.trim() ?? "";
+}
+function extractCanvasId(input) {
+  const trimmed = normalizeReferenceInput(input);
+  if (!trimmed) return void 0;
+  if (SLACK_FILE_ID_PATTERN.test(trimmed)) {
+    return trimmed.toUpperCase();
+  }
+  try {
+    const url = new URL(trimmed);
+    if (!isSlackHost(url.hostname)) {
+      return void 0;
+    }
+    const urlMatch = url.pathname.match(SLACK_CANVAS_PATH_PATTERN);
+    return urlMatch?.[1]?.toUpperCase();
+  } catch {
+    return void 0;
+  }
+}
+
 // src/chat/tools/slack/canvases.ts
 function normalizeCanvasMarkdown(markdown) {
   let normalizedHeadingCount = 0;
@@ -6264,27 +6419,7 @@ async function grantChannelCanvasAccess(canvasId, channelId) {
     );
   }
 }
-async function lookupCanvasSection(canvasId, containsText) {
-  const client2 = getSlackClient();
-  const response = await withSlackRetries(
-    () => client2.canvases.sections.lookup({
-      canvas_id: canvasId,
-      criteria: {
-        contains_text: containsText
-      }
-    }),
-    3,
-    {
-      action: "canvases.sections.lookup",
-      attributes: {
-        "app.slack.canvas.canvas_id_prefix": canvasId.slice(0, 1),
-        "app.slack.canvas.contains_text_length": containsText.length
-      }
-    }
-  );
-  return response.sections?.[0]?.id;
-}
-async function updateCanvas(input) {
+async function writeCanvasMarkdown(input) {
   const client2 = getSlackClient();
   const normalizedContent = normalizeCanvasMarkdown(input.markdown);
   await withSlackRetries(
@@ -6292,8 +6427,7 @@ async function updateCanvas(input) {
       canvas_id: input.canvasId,
       changes: [
         {
-          operation: input.operation,
-          section_id: input.sectionId,
+          operation: "replace",
           document_content: {
             type: "markdown",
             markdown: normalizedContent.markdown
@@ -6306,27 +6440,19 @@ async function updateCanvas(input) {
       action: "canvases.edit",
       attributes: {
         "app.slack.canvas.canvas_id_prefix": input.canvasId.slice(0, 1),
-        "app.slack.canvas.operation": input.operation,
+        "app.slack.canvas.operation": "replace",
         "app.slack.canvas.markdown_length": normalizedContent.markdown.length,
         "app.slack.canvas.markdown_normalized": normalizedContent.normalizedHeadingCount > 0,
         "app.slack.canvas.normalized_heading_count": normalizedContent.normalizedHeadingCount
       }
     }
   );
+  return normalizedContent;
 }
-var CANVAS_ID_PATTERN = /^F[A-Z0-9]+$/i;
-var CANVAS_URL_FILE_ID_PATTERN = /\/(?:docs|canvas|files)\/(?:T[A-Z0-9]+\/)?(?:U[A-Z0-9]+\/)?(F[A-Z0-9]+)/i;
-function extractCanvasId(input) {
-  const trimmed = input.trim();
-  if (!trimmed) return void 0;
-  if (CANVAS_ID_PATTERN.test(trimmed)) {
-    return trimmed.toUpperCase();
-  }
-  const urlMatch = trimmed.match(CANVAS_URL_FILE_ID_PATTERN);
-  if (urlMatch?.[1]) {
-    return urlMatch[1].toUpperCase();
-  }
-  return void 0;
+function isCanvasFile(file) {
+  const filetype = file.filetype?.toLowerCase() ?? "";
+  const mimetype = file.mimetype?.toLowerCase() ?? "";
+  return filetype === "quip" || filetype === "canvas" || mimetype.includes("quip") || mimetype.includes("canvas");
 }
 async function readCanvas(canvasIdOrUrl) {
   const canvasId = extractCanvasId(canvasIdOrUrl);
@@ -6352,6 +6478,9 @@ async function readCanvas(canvasIdOrUrl) {
   if (!file) {
     throw new Error("Slack returned no file metadata for canvas.");
   }
+  if (!isCanvasFile(file)) {
+    throw new Error("Slack file metadata did not describe a Canvas document.");
+  }
   const downloadUrl = file.url_private_download ?? file.url_private;
   if (!downloadUrl) {
     throw new Error(
@@ -6371,7 +6500,6 @@ async function readCanvas(canvasIdOrUrl) {
 }
 
 // src/chat/tools/slack/canvas-tools.ts
-var MAX_CANVAS_READ_CHARS = 4e4;
 var MAX_RECENT_CANVASES = 5;
 function mergeRecentCanvases(existing, created) {
   const nextEntry = {
@@ -6384,6 +6512,46 @@ function mergeRecentCanvases(existing, created) {
   const deduped = prior.filter((entry) => entry.id !== created.id);
   return [nextEntry, ...deduped].slice(0, MAX_RECENT_CANVASES);
 }
+function prepareCanvasEditArguments(input) {
+  return prepareTextReplacementArguments(input);
+}
+function storedCanvasUrl(state, canvasId) {
+  const lastCanvasUrl = state.artifactState.lastCanvasUrl;
+  if (lastCanvasUrl && extractCanvasId(lastCanvasUrl) === canvasId) {
+    return lastCanvasUrl;
+  }
+  for (const canvas of state.artifactState.recentCanvases ?? []) {
+    if (extractCanvasId(canvas.id) === canvasId) {
+      return canvas.url;
+    }
+    if (canvas.url && extractCanvasId(canvas.url) === canvasId) {
+      return canvas.url;
+    }
+  }
+  return void 0;
+}
+function resolveCanvasTarget(canvas) {
+  const canvasId = extractCanvasId(canvas);
+  if (!canvasId) {
+    return {
+      ok: false,
+      error: "Could not parse a Slack canvas/file ID from input. Provide an F-prefixed ID or a Slack canvas/docs URL."
+    };
+  }
+  return { ok: true, canvasId };
+}
+var editReplacementSchema2 = Type16.Object(
+  {
+    oldText: Type16.String({
+      minLength: 1,
+      description: "Exact Canvas markdown to replace. It must be unique in the current Canvas body and must not overlap another edit."
+    }),
+    newText: Type16.String({
+      description: "Replacement Canvas markdown for this edit."
+    })
+  },
+  { additionalProperties: false }
+);
 function createSlackCanvasCreateTool(context, state) {
   return tool({
     description: "Create a Slack canvas for long-form output in the active assistant context channel. Use when the answer is better as a reusable document than a thread reply: long-form research, timelines, bios/profiles, structured notes, plans, comparisons, or anything likely to exceed one compact Slack reply. After creating it, reply with one or two short sentences plus the canvas link; do not recap the canvas contents. Do not use for short answers that fit cleanly in one normal thread reply.",
@@ -6432,7 +6600,6 @@ function createSlackCanvasCreateTool(context, state) {
         markdown,
         channelId: targetChannelId
       });
-      state.setTurnCreatedCanvasId(created.canvasId);
       await state.patchArtifactState({
         lastCanvasId: created.canvasId,
         lastCanvasUrl: created.permalink,
@@ -6456,67 +6623,111 @@ function createSlackCanvasCreateTool(context, state) {
     }
   });
 }
-function createSlackCanvasUpdateTool(state, _context) {
+function createSlackCanvasReadTool() {
   return tool({
-    description: "Update the active Slack canvas tracked in artifact context. Use when continuing or correcting a document already tracked in this thread. Do not use to create a brand-new long-form artifact.",
-    inputSchema: Type16.Object({
-      markdown: Type16.String({
-        minLength: 1,
-        description: "Markdown content to insert or use as replacement text."
-      }),
-      operation: Type16.Optional(
-        Type16.Union(
-          [
-            Type16.Literal("insert_at_end"),
-            Type16.Literal("insert_at_start"),
-            Type16.Literal("replace")
-          ],
-          { description: "Canvas update mode." }
-        )
-      ),
-      section_id: Type16.Optional(
-        Type16.String({
-          minLength: 1,
-          description: "Optional section ID required for targeted replace operations."
-        })
-      ),
-      section_contains_text: Type16.Optional(
-        Type16.String({
+    description: "Read a bounded line range from a Slack canvas as markdown. Use when you need exact Canvas contents to verify facts or make edits safely. Do not use for generic web pages \u2014 use webFetch for those.",
+    annotations: { readOnlyHint: true, destructiveHint: false },
+    inputSchema: Type16.Object(
+      {
+        canvas: Type16.String({
           minLength: 1,
-          description: "Optional helper text used to find the target section when section_id is not provided."
-        })
-      )
-    }),
-    execute: async ({
-      markdown,
-      operation,
-      section_id,
-      section_contains_text
-    }) => {
-      const targetCanvasId = state.getTurnCreatedCanvasId() ?? state.getCurrentCanvasId();
-      const resolvedOperation = operation ?? "insert_at_end";
-      if (!targetCanvasId) {
+          description: "Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL (e.g. `https://team.slack.com/docs/T.../F...`)."
+        }),
+        offset: Type16.Optional(
+          Type16.Integer({
+            minimum: 1,
+            description: "1-indexed line number to start reading from."
+          })
+        ),
+        limit: Type16.Optional(
+          Type16.Integer({
+            minimum: 1,
+            description: "Maximum number of lines to read. Defaults to 1000."
+          })
+        )
+      },
+      { additionalProperties: false }
+    ),
+    execute: async ({ canvas, offset, limit }) => {
+      const target = resolveCanvasTarget(canvas);
+      if (!target.ok) {
+        return target;
+      }
+      try {
+        const result = await readCanvas(target.canvasId);
+        const range = sliceFileContent({
+          content: normalizeToLf(result.content),
+          limit,
+          offset,
+          path: result.canvasId
+        });
+        return {
+          ok: true,
+          canvas_id: result.canvasId,
+          title: result.title,
+          permalink: result.permalink,
+          mimetype: result.mimetype,
+          filetype: result.filetype,
+          original_byte_length: result.byteLength,
+          content: range.content,
+          start_line: range.start_line,
+          end_line: range.end_line,
+          total_lines: range.total_lines,
+          truncated: range.truncated,
+          continuation: range.continuation
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "canvas read failed";
         logWarn(
-          "slack_canvas_update_missing_target",
+          "slack_canvas_read_failed",
           {},
           {
-            "gen_ai.tool.name": "slackCanvasUpdate",
-            "app.artifacts.last_canvas_id": state.artifactState.lastCanvasId ?? "none",
-            "app.artifacts.turn_created_canvas_id": state.getTurnCreatedCanvasId() ?? "none"
+            "gen_ai.tool.name": "slackCanvasRead",
+            "app.slack.canvas.canvas_id_prefix": target.canvasId.slice(0, 1)
           },
-          "Canvas update rejected because no explicit target canvas was provided"
+          message
         );
         return {
           ok: false,
-          error: "No active canvas found in artifact context"
+          canvas_id: target.canvasId,
+          error: message
         };
       }
-      const operationKey = createOperationKey("slackCanvasUpdate", {
-        canvas_id: targetCanvasId,
-        markdown,
-        operation: resolvedOperation,
-        section_id: section_id ?? null,
-        section_contains_text: section_contains_text ?? null
+    }
+  });
+}
+function createSlackCanvasEditTool(state) {
+  return tool({
+    description: "Edit one Slack canvas with exact markdown replacements. Use for precise changes to existing Canvas content. Each oldText must match exactly, be unique, and not overlap another edit. Returns a diff.",
+    promptSnippet: "existing-canvas exact edits; returns diff",
+    promptGuidelines: [
+      "prefer over slackCanvasWrite for targeted changes",
+      "oldText exact, unique, non-overlapping",
+      "multiple same-canvas changes: one edits[] call"
+    ],
+    prepareArguments: prepareCanvasEditArguments,
+    executionMode: "sequential",
+    inputSchema: Type16.Object(
+      {
+        canvas: Type16.String({
+          minLength: 1,
+          description: "Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."
+        }),
+        edits: Type16.Array(editReplacementSchema2, {
+          minItems: 1,
+          description: "Exact replacements matched against the current Canvas body, not incrementally."
+        })
+      },
+      { additionalProperties: false }
+    ),
+    execute: async ({ canvas, edits }) => {
+      const target = resolveCanvasTarget(canvas);
+      if (!target.ok) {
+        return target;
+      }
+      const operationKey = createOperationKey("slackCanvasEdit", {
+        canvas_id: target.canvasId,
+        edits
       });
       const cached = state.getOperationResult(operationKey);
       if (cached) {
@@ -6525,72 +6736,124 @@ function createSlackCanvasUpdateTool(state, _context) {
           deduplicated: true
         };
       }
-      const sectionId = section_id ?? (section_contains_text ? await lookupCanvasSection(targetCanvasId, section_contains_text) : void 0);
-      await updateCanvas({
-        canvasId: targetCanvasId,
-        markdown,
-        operation: resolvedOperation,
-        sectionId
-      });
-      await state.patchArtifactState({ lastCanvasId: targetCanvasId });
-      const response = {
-        ok: true,
-        canvas_id: targetCanvasId,
-        operation: resolvedOperation,
-        section_id: sectionId
-      };
-      state.setOperationResult(operationKey, response);
-      return response;
+      try {
+        const current = await readCanvas(target.canvasId);
+        const normalizedContent = normalizeToLf(current.content);
+        const { baseContent, newContent } = validateAndApplyTextEdits(
+          normalizedContent,
+          edits,
+          target.canvasId
+        );
+        const written = await writeCanvasMarkdown({
+          canvasId: target.canvasId,
+          markdown: newContent
+        });
+        await state.patchArtifactState({
+          lastCanvasId: target.canvasId,
+          lastCanvasUrl: current.permalink ?? state.artifactState.lastCanvasUrl
+        });
+        const diff = buildCompactDiff(
+          normalizeCanvasMarkdown(baseContent).markdown,
+          written.markdown
+        );
+        const response = {
+          ok: true,
+          canvas_id: target.canvasId,
+          title: current.title,
+          permalink: current.permalink,
+          diff: diff.diff,
+          first_changed_line: diff.firstChangedLine,
+          replacements: edits.length,
+          normalized_heading_count: written.normalizedHeadingCount,
+          summary: `Edited canvas ${target.canvasId}`
+        };
+        state.setOperationResult(operationKey, response);
+        return response;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "canvas edit failed";
+        logWarn(
+          "slack_canvas_edit_failed",
+          {},
+          {
+            "gen_ai.tool.name": "slackCanvasEdit",
+            "app.slack.canvas.canvas_id_prefix": target.canvasId.slice(0, 1)
+          },
+          message
+        );
+        return {
+          ok: false,
+          canvas_id: target.canvasId,
+          error: message
+        };
+      }
     }
   });
 }
-function createSlackCanvasReadTool() {
+function createSlackCanvasWriteTool(state) {
   return tool({
-    description: "Read a Slack canvas the bot has access to (including canvases the bot created) by canvas ID or Slack canvas/docs URL. Use when the user shares a Slack canvas link (https://*.slack.com/docs/... or /canvas/...) or references a canvas ID and you need its contents. Do not use for generic web pages \u2014 use webFetch for those.",
-    annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: Type16.Object({
-      canvas: Type16.String({
-        minLength: 1,
-        description: "Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL (e.g. `https://team.slack.com/docs/T.../F...`)."
-      })
-    }),
-    execute: async ({ canvas }) => {
-      const canvasId = extractCanvasId(canvas);
-      if (!canvasId) {
+    description: "Write UTF-8 markdown content to a Slack canvas. Use for deliberate full-Canvas replacement after validation. Do not use for targeted edits.",
+    promptSnippet: "deliberate full-canvas replacement",
+    promptGuidelines: ["targeted existing-canvas changes: slackCanvasEdit"],
+    executionMode: "sequential",
+    inputSchema: Type16.Object(
+      {
+        canvas: Type16.String({
+          minLength: 1,
+          description: "Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."
+        }),
+        content: Type16.String({
+          description: "UTF-8 markdown content to write."
+        })
+      },
+      { additionalProperties: false }
+    ),
+    execute: async ({ canvas, content }) => {
+      const target = resolveCanvasTarget(canvas);
+      if (!target.ok) {
+        return target;
+      }
+      const operationKey = createOperationKey("slackCanvasWrite", {
+        canvas_id: target.canvasId,
+        content
+      });
+      const cached = state.getOperationResult(operationKey);
+      if (cached) {
         return {
-          ok: false,
-          error: "Could not parse a Slack canvas/file ID from input. Provide an F-prefixed ID or a Slack canvas/docs URL."
+          ...cached,
+          deduplicated: true
         };
       }
       try {
-        const result = await readCanvas(canvas);
-        const truncated = result.content.length > MAX_CANVAS_READ_CHARS;
-        const content = truncated ? result.content.slice(0, MAX_CANVAS_READ_CHARS) : result.content;
-        return {
+        const written = await writeCanvasMarkdown({
+          canvasId: target.canvasId,
+          markdown: content
+        });
+        await state.patchArtifactState({
+          lastCanvasId: target.canvasId,
+          lastCanvasUrl: storedCanvasUrl(state, target.canvasId)
+        });
+        const response = {
           ok: true,
-          canvas_id: result.canvasId,
-          title: result.title,
-          permalink: result.permalink,
-          mimetype: result.mimetype,
-          filetype: result.filetype,
-          original_byte_length: result.byteLength,
-          truncated,
-          content
+          canvas_id: target.canvasId,
+          normalized_heading_count: written.normalizedHeadingCount,
+          summary: `Wrote canvas ${target.canvasId}`
         };
+        state.setOperationResult(operationKey, response);
+        return response;
       } catch (error) {
-        const message = error instanceof Error ? error.message : "canvas read failed";
+        const message = error instanceof Error ? error.message : "canvas write failed";
         logWarn(
-          "slack_canvas_read_failed",
+          "slack_canvas_write_failed",
           {},
           {
-            "gen_ai.tool.name": "slackCanvasRead",
-            "app.slack.canvas.canvas_id_prefix": canvasId.slice(0, 1)
+            "gen_ai.tool.name": "slackCanvasWrite",
+            "app.slack.canvas.canvas_id_prefix": target.canvasId.slice(0, 1)
           },
           message
         );
         return {
           ok: false,
-          canvas_id: canvasId,
+          canvas_id: target.canvasId,
           error: message
         };
       }
@@ -8522,7 +8785,6 @@ function createWriteFileTool() {
 // src/chat/tools/index.ts
 function createToolState(hooks, context) {
   const operationResultCache = /* @__PURE__ */ new Map();
-  let turnCreatedCanvasId;
   const artifactState = {
     ...context.artifactState ?? {},
     listColumnMap: {
@@ -8542,11 +8804,6 @@ function createToolState(hooks, context) {
   return {
     artifactState,
     patchArtifactState,
-    getCurrentCanvasId: () => artifactState.lastCanvasId,
-    getTurnCreatedCanvasId: () => turnCreatedCanvasId,
-    setTurnCreatedCanvasId: (canvasId) => {
-      turnCreatedCanvasId = canvasId;
-    },
     getCurrentListId: () => artifactState.lastListId,
     getOperationResult: (operationKey) => operationResultCache.get(operationKey),
     setOperationResult: (operationKey, result) => {
@@ -8577,7 +8834,8 @@ function createTools(availableSkills, hooks = {}, context) {
       hooks.toolOverrides?.imageGenerate
     ),
     slackCanvasRead: createSlackCanvasReadTool(),
-    slackCanvasUpdate: createSlackCanvasUpdateTool(state, context),
+    slackCanvasEdit: createSlackCanvasEditTool(state),
+    slackCanvasWrite: createSlackCanvasWriteTool(state),
     slackThreadRead: createSlackThreadReadTool(context),
     slackUserLookup: createSlackUserLookupTool(),
     slackListCreate: createSlackListCreateTool(state),
@@ -8631,7 +8889,6 @@ function resolveChannelCapabilities(channelId) {
 import fs4 from "fs/promises";
 
 // src/chat/sandbox/egress-policy.ts
-var SANDBOX_EGRESS_PROXY_PATH = "/api/internal/sandbox-egress";
 function matchesSandboxEgressDomain(host, domain) {
   return host.toLowerCase() === domain.toLowerCase();
 }
@@ -8653,31 +8910,24 @@ function resolveSandboxEgressProviderForHost(host) {
     (entry) => entry.domains.some((domain) => matchesSandboxEgressDomain(host, domain))
   )?.provider;
 }
-function proxyUrl(egressId) {
+function sandboxProxyUrl() {
   const baseUrl = resolveBaseUrl();
   if (!baseUrl) {
-    return void 0;
-  }
-  const url = new URL(
-    `${SANDBOX_EGRESS_PROXY_PATH}/${encodeURIComponent(egressId)}`,
-    baseUrl
-  );
-  return url.toString();
-}
-function buildSandboxEgressNetworkPolicy(egressId) {
-  const entries = providerEntries();
-  if (entries.length === 0) {
-    return void 0;
-  }
-  const forwardURL = proxyUrl(egressId);
-  if (!forwardURL) {
     throw new Error(
       "Cannot determine base URL for sandbox credential egress (set JUNIOR_BASE_URL or deploy to Vercel)"
     );
   }
+  return new URL("/", baseUrl).toString();
+}
+function buildSandboxEgressNetworkPolicy() {
   const allow = {
     "*": []
   };
+  const entries = providerEntries();
+  if (entries.length === 0) {
+    return { allow };
+  }
+  const forwardURL = sandboxProxyUrl();
   for (const entry of entries) {
     for (const domain of entry.domains) {
       allow[domain] = [{ forwardURL }];
@@ -8685,11 +8935,14 @@ function buildSandboxEgressNetworkPolicy(egressId) {
   }
   return { allow };
 }
-async function resolveSandboxCommandEnvironment() {
+async function resolveSandboxCommandEnvironment(provider) {
   const env = {};
   for (const plugin of getPluginProviders().sort(
     (left, right) => left.manifest.name.localeCompare(right.manifest.name)
   )) {
+    if (provider && plugin.manifest.name !== provider) {
+      continue;
+    }
     Object.assign(env, resolvePluginCommandEnv(plugin.manifest));
     const credentials = plugin.manifest.credentials;
     if (credentials) {
@@ -10006,7 +10259,6 @@ function createSandboxSessionManager(options) {
     return {
       bash: async (input) => {
         const commandEgressId = sandboxInstance.sandboxEgressId;
-        await options?.beforeCommand?.(commandEgressId);
         let timedOut = false;
         let timeoutId;
         let commandFinished = false;
@@ -10016,6 +10268,7 @@ function createSandboxSessionManager(options) {
           }
           commandFinished = true;
           await options?.afterCommand?.(commandEgressId);
+          await refreshNetworkPolicy(sandboxInstance);
         };
         const finishCommandBestEffort = async () => {
           try {
@@ -10033,6 +10286,8 @@ function createSandboxSessionManager(options) {
           }
         };
         try {
+          await options?.beforeCommand?.(commandEgressId);
+          await refreshNetworkPolicy(sandboxInstance);
           const sandboxCommandEnv = await resolveCommandEnv();
           const script = buildNonInteractiveShellScript(input.command, {
             env: { ...sandboxCommandEnv, ...input.env ?? {} },
@@ -10156,14 +10411,14 @@ function createSandboxExecutor(options) {
   let referenceFiles = [];
   const traceContext = options?.traceContext ?? {};
   const credentialEgress = options?.credentialEgress;
-  const syncSandboxEgressSession = credentialEgress ? async (egressId) => {
+  const authorizeSandboxEgressForCommand = credentialEgress ? async (egressId) => {
     await upsertSandboxEgressSession({
       egressId,
       requesterId: credentialEgress.requesterId,
       ttlMs: options?.timeoutMs
     });
   } : void 0;
-  const clearSandboxEgressSessionForCommand = credentialEgress ? async (egressId) => {
+  const clearSandboxEgressForCommand = credentialEgress ? async (egressId) => {
     await clearSandboxEgressSession(egressId);
   } : void 0;
   const sessionManager = createSandboxSessionManager({
@@ -10171,10 +10426,13 @@ function createSandboxExecutor(options) {
     sandboxDependencyProfileHash: options?.sandboxDependencyProfileHash,
     timeoutMs: options?.timeoutMs,
     traceContext,
-    commandEnv: credentialEgress ? async () => await resolveSandboxCommandEnvironment() : void 0,
+    commandEnv: credentialEgress ? async () => {
+      const provider = credentialEgress.activeProvider?.();
+      return provider ? await resolveSandboxCommandEnvironment(provider) : {};
+    } : void 0,
     createNetworkPolicy: credentialEgress ? buildSandboxEgressNetworkPolicy : void 0,
-    beforeCommand: syncSandboxEgressSession,
-    afterCommand: clearSandboxEgressSessionForCommand,
+    beforeCommand: authorizeSandboxEgressForCommand,
+    afterCommand: clearSandboxEgressForCommand,
     onSandboxAcquired: async (sandbox) => {
       await options?.onSandboxAcquired?.(sandbox);
     }
@@ -10297,7 +10555,16 @@ function createSandboxExecutor(options) {
         "app.sandbox.path.length": filePath.length
       },
       async () => {
-        const response = await executeReadFile({ path: filePath });
+        let response;
+        try {
+          response = await executeReadFile({ path: filePath });
+        } catch (error) {
+          if (isMissingPathError(error)) {
+            setSpanStatus("ok");
+            return missingFileResult(filePath);
+          }
+          throw error;
+        }
         const content = String(response.content ?? "");
         setSpanAttributes({
           "app.sandbox.read.bytes": Buffer.byteLength(content, "utf8"),
@@ -12098,7 +12365,8 @@ async function generateAssistantReply(messageText, context = {}) {
       sandboxDependencyProfileHash: context.sandbox?.sandboxDependencyProfileHash,
       traceContext: spanContext,
       credentialEgress: requesterId ? {
-        requesterId
+        requesterId,
+        activeProvider: () => skillSandbox.getActiveSkill()?.pluginProvider
       } : void 0,
       onSandboxAcquired: async (sandbox2) => {
         lastKnownSandboxId = sandbox2.sandboxId;
@@ -13480,102 +13748,343 @@ async function postSlackApiReplyPosts(args) {
   return lastPostedMessageTs;
 }
 
-// src/chat/runtime/slack-resume.ts
-function resolveReplyTimeoutMs(explicitTimeoutMs) {
-  if (typeof explicitTimeoutMs === "number" && explicitTimeoutMs > 0) {
-    return explicitTimeoutMs;
-  }
-  const raw = process.env.EVAL_AGENT_REPLY_TIMEOUT_MS?.trim();
-  if (!raw) {
+// src/chat/slack/errors.ts
+function getSlackApiErrorCode(error) {
+  if (!error || typeof error !== "object") {
     return void 0;
   }
-  const parsed = Number.parseInt(raw, 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+  const candidate = error;
+  if (typeof candidate.data?.error === "string" && candidate.data.error.trim().length > 0) {
+    return candidate.data.error;
+  }
+  if (typeof candidate.code === "string" && candidate.code.trim().length > 0) {
+    return candidate.code;
+  }
+  return void 0;
 }
-async function postSlackMessageBestEffort(channelId, threadTs, text) {
-  try {
-    await postSlackMessage({
-      channelId,
-      threadTs,
-      text
-    });
-  } catch {
+function getSlackErrorObservabilityAttributes(error) {
+  if (!error || typeof error !== "object") {
+    return {};
+  }
+  const candidate = error;
+  const attributes = {};
+  if (typeof candidate.code === "string" && candidate.code.trim().length > 0) {
+    attributes["app.slack.error_code"] = candidate.code;
+  }
+  if (typeof candidate.data?.error === "string" && candidate.data.error.trim().length > 0) {
+    attributes["app.slack.api_error"] = candidate.data.error;
+  }
+  const requestId = getHeaderString(candidate.headers, "x-slack-req-id");
+  if (requestId) {
+    attributes["app.slack.request_id"] = requestId;
+  }
+  if (typeof candidate.statusCode === "number" && Number.isFinite(candidate.statusCode)) {
+    attributes["http.response.status_code"] = candidate.statusCode;
   }
+  return attributes;
 }
-function createReadOnlyConfigService(values) {
-  const entries = Object.entries(values).map(([key, value]) => ({
-    key,
-    value,
-    scope: "conversation",
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  }));
-  return {
-    get: async (key) => entries.find((entry) => entry.key === key),
-    set: async () => {
-      throw new Error("Read-only configuration in resumed context");
-    },
-    unset: async () => false,
-    list: async ({ prefix } = {}) => entries.filter((entry) => !prefix || entry.key.startsWith(prefix)),
-    resolve: async (key) => values[key],
-    resolveValues: async ({ keys, prefix } = {}) => {
-      const filtered = {};
-      for (const [key, value] of Object.entries(values)) {
-        if (prefix && !key.startsWith(prefix)) continue;
-        if (keys && !keys.includes(key)) continue;
-        filtered[key] = value;
-      }
-      return filtered;
-    }
-  };
+function isSlackTitlePermissionError(error) {
+  const code = getSlackApiErrorCode(error);
+  return code === "no_permission" || code === "missing_scope" || code === "not_allowed_token_type";
 }
-var ResumeTurnBusyError = class extends Error {
-  constructor(lockKey) {
-    super(`A turn already owns resume lock "${lockKey}"`);
-    this.name = "ResumeTurnBusyError";
+
+// src/chat/slack/context.ts
+function toTrimmedSlackString(value) {
+  const normalized = toOptionalString(value);
+  return normalized?.trim() || void 0;
+}
+function parseSlackThreadId(threadId) {
+  const normalizedThreadId = toTrimmedSlackString(threadId);
+  if (!normalizedThreadId) {
+    return void 0;
   }
-};
-function getDefaultLockKey(channelId, threadTs) {
-  return `slack:${channelId}:${threadTs}`;
+  const parts = normalizedThreadId.split(":");
+  if (parts.length !== 3 || parts[0] !== "slack") {
+    return void 0;
+  }
+  const channelId = toTrimmedSlackString(parts[1]);
+  const threadTs = toTrimmedSlackString(parts[2]);
+  if (!channelId || !threadTs) {
+    return void 0;
+  }
+  return { channelId, threadTs };
 }
-function getResumeLogContext(args, lockKey) {
-  return {
-    conversationId: args.replyContext?.correlation?.conversationId ?? lockKey,
-    slackThreadId: args.replyContext?.correlation?.threadId ?? lockKey,
-    slackUserId: args.replyContext?.requester?.userId ?? args.replyContext?.correlation?.requesterId,
-    slackUserName: args.replyContext?.requester?.userName,
-    slackChannelId: args.channelId,
-    runId: args.replyContext?.correlation?.runId,
-    assistantUserName: botConfig.userName,
-    modelId: botConfig.modelId
-  };
+function resolveSlackChannelIdFromThreadId(threadId) {
+  return parseSlackThreadId(threadId)?.channelId;
 }
-async function postResumeFailureReply(args) {
-  try {
-    await postSlackMessage({
-      channelId: args.channelId,
-      threadTs: args.threadTs,
-      text: buildTurnFailureResponse(args.eventId)
-    });
-  } catch (error) {
-    logException(
-      error,
-      "slack_resume_failure_reply_post_failed",
-      args.logContext,
-      {
-        "app.error.original_event_id": args.eventId
-      },
-      "Failed to post resumed turn failure reply"
+function resolveSlackChannelIdFromMessage(message) {
+  const messageChannelId = toTrimmedSlackString(
+    message.channelId
+  );
+  if (messageChannelId) {
+    return messageChannelId;
+  }
+  const raw = message.raw;
+  if (raw && typeof raw === "object") {
+    const rawChannel = toTrimmedSlackString(
+      raw.channel
     );
-    throw error;
+    if (rawChannel) {
+      return rawChannel;
+    }
   }
+  const threadId = toTrimmedSlackString(
+    message.threadId
+  );
+  return resolveSlackChannelIdFromThreadId(threadId);
 }
-async function postTurnContinuationNoticeBestEffort(args) {
-  try {
-    await postSlackMessage({
-      channelId: args.resumeArgs.channelId,
-      threadTs: args.resumeArgs.threadTs,
-      text: buildTurnContinuationResponse()
-    });
+
+// src/chat/runtime/thread-context.ts
+function escapeRegExp2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function stripLeadingBotMention(text, options = {}) {
+  if (!text.trim()) return text;
+  let next = text;
+  if (options.stripLeadingSlackMentionToken) {
+    next = next.replace(/^\s*<@[^>]+>[\s,:-]*/, "").trim();
+  }
+  const mentionByNameRe = new RegExp(
+    `^\\s*@${escapeRegExp2(botConfig.userName)}\\b[\\s,:-]*`,
+    "i"
+  );
+  next = next.replace(mentionByNameRe, "").trim();
+  const mentionByLabeledEntityRe = new RegExp(
+    `^\\s*<@[^>|]+\\|${escapeRegExp2(botConfig.userName)}>[\\s,:-]*`,
+    "i"
+  );
+  next = next.replace(mentionByLabeledEntityRe, "").trim();
+  return next;
+}
+function getThreadId(thread, _message) {
+  return toOptionalString(thread.id);
+}
+function getRunId(thread, message) {
+  return toOptionalString(thread.runId) ?? toOptionalString(message.runId);
+}
+function getChannelId(thread, message) {
+  return resolveSlackChannelIdFromThreadId(toOptionalString(thread.id)) ?? normalizeSlackConversationId(toOptionalString(thread.channelId)) ?? resolveSlackChannelIdFromMessage(message);
+}
+function getThreadTs(threadId) {
+  return parseSlackThreadId(threadId)?.threadTs;
+}
+function getAssistantThreadContext(message) {
+  const raw = message.raw;
+  const rawRecord = raw && typeof raw === "object" ? raw : void 0;
+  const channelId = toOptionalString(rawRecord?.channel);
+  if (channelId) {
+    const rawThreadTs = toOptionalString(rawRecord?.thread_ts);
+    const threadTs = isDmChannel(channelId) ? rawThreadTs : rawThreadTs ?? toOptionalString(rawRecord?.ts);
+    if (threadTs) {
+      return { channelId, threadTs };
+    }
+  }
+  const parsedThreadId = parseSlackThreadId(
+    toOptionalString(message.threadId)
+  );
+  if (!parsedThreadId || isDmChannel(parsedThreadId.channelId)) {
+    return void 0;
+  }
+  return parsedThreadId;
+}
+function getMessageTs(message) {
+  const directTs = toOptionalString(
+    message.ts
+  );
+  if (directTs) {
+    return directTs;
+  }
+  const raw = message.raw;
+  if (!raw || typeof raw !== "object") {
+    return void 0;
+  }
+  const rawRecord = raw;
+  return toOptionalString(rawRecord.ts) ?? toOptionalString(rawRecord.event_ts) ?? toOptionalString(rawRecord.message?.ts);
+}
+
+// src/chat/runtime/processing-reaction.ts
+var PROCESSING_REACTION_EMOJI = "eyes";
+var noProcessingReaction = {
+  keep: () => void 0,
+  stop: async () => void 0
+};
+function isProcessingReactionEmoji(value) {
+  return typeof value === "string" && normalizeSlackEmojiName(value) === PROCESSING_REACTION_EMOJI;
+}
+function shouldKeepProcessingReactionForToolInvocation(input) {
+  return input.toolName === "slackMessageAddReaction" && isProcessingReactionEmoji(input.params.emoji);
+}
+async function startSlackProcessingReaction(args) {
+  if (args.message.author.isMe) {
+    return noProcessingReaction;
+  }
+  const channelId = getChannelId(args.thread, args.message);
+  const messageTs = getMessageTs(args.message);
+  if (!channelId || !messageTs) {
+    return noProcessingReaction;
+  }
+  return startSlackProcessingReactionForMessage({
+    channelId,
+    timestamp: messageTs,
+    logException: args.logException,
+    logContext: args.logContext
+  });
+}
+async function startSlackProcessingReactionForMessage(args) {
+  try {
+    await addReactionToMessage({
+      channelId: args.channelId,
+      timestamp: args.timestamp,
+      emoji: PROCESSING_REACTION_EMOJI
+    });
+  } catch (error) {
+    args.logException(
+      error,
+      "slack_processing_reaction_add_failed",
+      args.logContext,
+      {
+        "app.slack.action": "reactions.add",
+        "messaging.message.id": args.timestamp,
+        ...getSlackErrorObservabilityAttributes(error)
+      },
+      "Failed to add Slack processing reaction"
+    );
+    return noProcessingReaction;
+  }
+  let shouldRemove = true;
+  return {
+    keep: () => {
+      shouldRemove = false;
+    },
+    stop: async () => {
+      if (!shouldRemove) {
+        return;
+      }
+      try {
+        await removeReactionFromMessage({
+          channelId: args.channelId,
+          timestamp: args.timestamp,
+          emoji: PROCESSING_REACTION_EMOJI
+        });
+      } catch (error) {
+        args.logException(
+          error,
+          "slack_processing_reaction_remove_failed",
+          args.logContext,
+          {
+            "app.slack.action": "reactions.remove",
+            "messaging.message.id": args.timestamp,
+            ...getSlackErrorObservabilityAttributes(error)
+          },
+          "Failed to remove Slack processing reaction"
+        );
+      }
+    }
+  };
+}
+
+// src/chat/services/auth-pause-response.ts
+var AUTH_PAUSE_RESPONSE = "I need authorization to continue. Check your private link to connect.";
+function buildAuthPauseResponse() {
+  return AUTH_PAUSE_RESPONSE;
+}
+
+// src/chat/runtime/slack-resume.ts
+function resolveReplyTimeoutMs(explicitTimeoutMs) {
+  if (typeof explicitTimeoutMs === "number" && explicitTimeoutMs > 0) {
+    return explicitTimeoutMs;
+  }
+  const raw = process.env.EVAL_AGENT_REPLY_TIMEOUT_MS?.trim();
+  if (!raw) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+async function postSlackMessageBestEffort(channelId, threadTs, text) {
+  try {
+    await postSlackMessage({
+      channelId,
+      threadTs,
+      text
+    });
+  } catch {
+  }
+}
+function createReadOnlyConfigService(values) {
+  const entries = Object.entries(values).map(([key, value]) => ({
+    key,
+    value,
+    scope: "conversation",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }));
+  return {
+    get: async (key) => entries.find((entry) => entry.key === key),
+    set: async () => {
+      throw new Error("Read-only configuration in resumed context");
+    },
+    unset: async () => false,
+    list: async ({ prefix } = {}) => entries.filter((entry) => !prefix || entry.key.startsWith(prefix)),
+    resolve: async (key) => values[key],
+    resolveValues: async ({ keys, prefix } = {}) => {
+      const filtered = {};
+      for (const [key, value] of Object.entries(values)) {
+        if (prefix && !key.startsWith(prefix)) continue;
+        if (keys && !keys.includes(key)) continue;
+        filtered[key] = value;
+      }
+      return filtered;
+    }
+  };
+}
+var ResumeTurnBusyError = class extends Error {
+  constructor(lockKey) {
+    super(`A turn already owns resume lock "${lockKey}"`);
+    this.name = "ResumeTurnBusyError";
+  }
+};
+function getDefaultLockKey(channelId, threadTs) {
+  return `slack:${channelId}:${threadTs}`;
+}
+function getResumeLogContext(args, lockKey) {
+  return {
+    conversationId: args.replyContext?.correlation?.conversationId ?? lockKey,
+    slackThreadId: args.replyContext?.correlation?.threadId ?? lockKey,
+    slackUserId: args.replyContext?.requester?.userId ?? args.replyContext?.correlation?.requesterId,
+    slackUserName: args.replyContext?.requester?.userName,
+    slackChannelId: args.channelId,
+    runId: args.replyContext?.correlation?.runId,
+    assistantUserName: botConfig.userName,
+    modelId: botConfig.modelId
+  };
+}
+async function postResumeFailureReply(args) {
+  try {
+    await postSlackMessage({
+      channelId: args.channelId,
+      threadTs: args.threadTs,
+      text: buildTurnFailureResponse(args.eventId)
+    });
+  } catch (error) {
+    logException(
+      error,
+      "slack_resume_failure_reply_post_failed",
+      args.logContext,
+      {
+        "app.error.original_event_id": args.eventId
+      },
+      "Failed to post resumed turn failure reply"
+    );
+    throw error;
+  }
+}
+async function postTurnContinuationNoticeBestEffort(args) {
+  try {
+    await postSlackMessage({
+      channelId: args.resumeArgs.channelId,
+      threadTs: args.resumeArgs.threadTs,
+      text: buildTurnContinuationResponse()
+    });
   } catch (error) {
     logException(
       error,
@@ -13655,10 +14164,19 @@ async function resumeSlackTurn(args) {
     channelId: args.channelId,
     threadTs: args.threadTs
   });
+  let processingReaction;
   let deferredPauseKind;
   let deferredPauseHandler;
   let deferredFailureHandler;
   try {
+    if (args.messageTs) {
+      processingReaction = await startSlackProcessingReactionForMessage({
+        channelId: args.channelId,
+        timestamp: args.messageTs,
+        logException,
+        logContext: { ...getResumeLogContext(args, lockKey) }
+      });
+    }
     if (args.initialText) {
       await postSlackMessageBestEffort(
         args.channelId,
@@ -13730,11 +14248,19 @@ async function resumeSlackTurn(args) {
       };
     }
   } finally {
+    await processingReaction?.stop();
     await stateAdapter.releaseLock(lock);
   }
   if (deferredPauseHandler) {
     try {
       await deferredPauseHandler();
+      if (deferredPauseKind === "auth") {
+        await postSlackMessageBestEffort(
+          args.channelId,
+          args.threadTs,
+          buildAuthPauseResponse()
+        );
+      }
       if (deferredPauseKind === "timeout") {
         await postTurnContinuationNoticeBestEffort({
           lockKey,
@@ -13762,6 +14288,7 @@ async function resumeAuthorizedRequest(args) {
     messageText: args.messageText,
     channelId: args.channelId,
     threadTs: args.threadTs,
+    messageTs: args.messageTs,
     replyContext: args.replyContext,
     lockKey: args.lockKey,
     initialText: args.connectedText,
@@ -14084,6 +14611,7 @@ async function resumeAuthorizedMcpTurn(args) {
     messageText: userMessage.text,
     channelId: authSession.channelId,
     threadTs: authSession.threadTs,
+    messageTs: getTurnUserSlackMessageTs(userMessage),
     lockKey: authSession.conversationId,
     connectedText: "",
     replyContext: {
@@ -14525,6 +15053,7 @@ async function resumeCheckpointedOAuthTurn(stored) {
     messageText: stored.pendingMessage ?? userMessage.text,
     channelId: stored.channelId,
     threadTs: stored.threadTs,
+    messageTs: getTurnUserSlackMessageTs(userMessage),
     lockKey: stored.resumeConversationId,
     initialText: "",
     replyContext: {
@@ -14617,14 +15146,15 @@ async function resumePendingOAuthMessage(stored) {
   const conversation = coerceThreadConversationState(
     await getPersistedThreadState(threadId)
   );
-  const latestUserMessageId = [...conversation.messages].reverse().find((message) => message.role === "user")?.id;
+  const latestUserMessage = [...conversation.messages].reverse().find((message) => message.role === "user");
   const conversationContext = buildConversationContext(conversation, {
-    excludeMessageId: latestUserMessageId
+    excludeMessageId: latestUserMessage?.id
   });
   await resumeAuthorizedRequest({
     messageText: stored.pendingMessage,
     channelId: stored.channelId,
     threadTs: stored.threadTs,
+    messageTs: getTurnUserSlackMessageTs(latestUserMessage),
     connectedText: "",
     replyContext: {
       requester: { userId: stored.userId },
@@ -14881,12 +15411,7 @@ async function getJwks(issuer) {
   });
   return jwks;
 }
-function validateSandboxClaim(payload, egressId) {
-  if (payload.sandbox_id !== egressId) {
-    throw new Error("Vercel OIDC token belongs to a different sandbox");
-  }
-}
-async function verifyVercelSandboxOidcToken(token, egressId) {
+async function verifyVercelSandboxOidcToken(token) {
   const unverified = decodeJwt(token);
   if (typeof unverified.iss !== "string") {
     throw new Error("Vercel OIDC token did not include an issuer");
@@ -14895,7 +15420,6 @@ async function verifyVercelSandboxOidcToken(token, egressId) {
   const verified = await jwtVerify(token, jwks, {
     issuer: unverified.iss
   });
-  validateSandboxClaim(verified.payload, egressId);
   return verified.payload;
 }
 
@@ -14904,7 +15428,7 @@ var OIDC_TOKEN_HEADER = "vercel-sandbox-oidc-token";
 var FORWARDED_HOST_HEADER = "vercel-forwarded-host";
 var FORWARDED_SCHEME_HEADER = "vercel-forwarded-scheme";
 var FORWARDED_PORT_HEADER = "vercel-forwarded-port";
-var ROUTE_PREFIX = "/api/internal/sandbox-egress";
+var FORWARDED_PATH_HEADER = "vercel-forwarded-path";
 var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
   "connection",
   "host",
@@ -14920,7 +15444,8 @@ var PROXY_ONLY_HEADERS = /* @__PURE__ */ new Set([
   OIDC_TOKEN_HEADER,
   FORWARDED_HOST_HEADER,
   FORWARDED_SCHEME_HEADER,
-  FORWARDED_PORT_HEADER
+  FORWARDED_PORT_HEADER,
+  FORWARDED_PATH_HEADER
 ]);
 var DECODED_RESPONSE_HEADERS = /* @__PURE__ */ new Set([
   "content-encoding",
@@ -14930,6 +15455,52 @@ var AUTH_REJECTION_STATUS = /* @__PURE__ */ new Set([401, 403]);
 function jsonError(message, status) {
   return Response.json({ error: message }, { status });
 }
+function shouldLogSandboxEgressInfo() {
+  const environment = (process.env.SENTRY_ENVIRONMENT ?? process.env.VERCEL_ENV ?? process.env.NODE_ENV ?? "").trim().toLowerCase();
+  return environment !== "production";
+}
+function egressAttributes(input) {
+  return {
+    ...input.egressId ? { "app.sandbox.egress_id": input.egressId } : {},
+    ...input.provider ? { "app.credential.provider": input.provider } : {},
+    ...input.host ? { "server.address": input.host } : {},
+    ...input.method ? { "http.request.method": input.method } : {},
+    ...input.path ? { "url.path": input.path } : {},
+    ...input.status ? { "http.response.status_code": input.status } : {}
+  };
+}
+function routingAttributes(request, upstreamUrl) {
+  const proxyUrl = new URL(request.url);
+  const attributes = {
+    "app.sandbox.egress.proxy_path": proxyUrl.pathname
+  };
+  if (upstreamUrl) {
+    attributes["app.sandbox.egress.upstream_path"] = upstreamUrl.pathname;
+  }
+  return attributes;
+}
+function logSandboxEgressUpstreamRequest(input) {
+  if (!shouldLogSandboxEgressInfo()) {
+    return;
+  }
+  logInfo(
+    "sandbox_egress_upstream_request",
+    {},
+    {
+      ...egressAttributes({
+        egressId: input.egressId,
+        host: input.upstreamUrl.hostname,
+        method: input.request.method,
+        path: input.upstreamUrl.pathname,
+        provider: input.provider,
+        status: input.upstream.status
+      }),
+      ...routingAttributes(input.request, input.upstreamUrl),
+      "app.sandbox.egress.upstream_ok": input.upstream.ok
+    },
+    `Sandbox egress ${input.request.method} ${input.upstreamUrl.hostname}${input.upstreamUrl.pathname} -> ${input.upstream.status}`
+  );
+}
 function normalizeHost(value) {
   const trimmed = value.trim().toLowerCase();
   if (!trimmed || trimmed.includes("/") || trimmed.includes("\\") || trimmed.includes(":")) {
@@ -14951,18 +15522,27 @@ function normalizePort(value) {
   const port = Number.parseInt(trimmed, 10);
   return port >= 1 && port <= 65535 ? trimmed : void 0;
 }
-function upstreamPath(request, egressId) {
-  const url = new URL(request.url);
-  const prefix = `${ROUTE_PREFIX}/${encodeURIComponent(egressId)}`;
-  if (url.pathname === prefix) {
-    return `/${url.search}`;
-  }
-  if (url.pathname.startsWith(`${prefix}/`)) {
-    return `${url.pathname.slice(prefix.length)}${url.search}`;
+function sandboxIdFromPayload(payload) {
+  return typeof payload.sandbox_id === "string" ? payload.sandbox_id : void 0;
+}
+function upstreamPath(request) {
+  const forwardedPath = request.headers.get(FORWARDED_PATH_HEADER);
+  if (forwardedPath?.trim()) {
+    const path11 = forwardedPath.trim();
+    if (!path11.startsWith("/") || path11.startsWith("//") || path11.includes("#") || /[\r\n]/.test(path11)) {
+      return { ok: false, error: "Invalid forwarded path" };
+    }
+    try {
+      const url2 = new URL(path11, "https://sandbox-forwarded.local");
+      return { ok: true, path: `${url2.pathname}${url2.search}` };
+    } catch {
+      return { ok: false, error: "Invalid forwarded path" };
+    }
   }
-  return void 0;
+  const url = new URL(request.url);
+  return { ok: true, path: `${url.pathname}${url.search}` };
 }
-function buildUpstreamUrl(request, egressId) {
+function buildUpstreamUrl(request) {
   const forwardedHost = request.headers.get(FORWARDED_HOST_HEADER);
   if (!forwardedHost?.trim()) {
     return { ok: false, error: "Missing forwarded host" };
@@ -14984,12 +15564,14 @@ function buildUpstreamUrl(request, egressId) {
   if (forwardedPort && !port) {
     return { ok: false, error: "Invalid forwarded port" };
   }
-  const path11 = upstreamPath(request, egressId);
-  if (!path11) {
-    return { ok: false, error: "Invalid egress route" };
+  const path11 = upstreamPath(request);
+  if (!path11.ok) {
+    return { ok: false, error: path11.error };
   }
   try {
-    const url = new URL(`${scheme}://${host}${port ? `:${port}` : ""}${path11}`);
+    const url = new URL(
+      `${scheme}://${host}${port ? `:${port}` : ""}${path11.path}`
+    );
     return { ok: true, url };
   } catch {
     return { ok: false, error: "Invalid forwarded URL" };
@@ -15063,15 +15645,20 @@ function hasTransformForHost(lease, host) {
     (transform) => matchesSandboxEgressDomain(host, transform.domain)
   );
 }
-async function proxySandboxEgressRequest(request, egressId, deps = {}) {
+function isSandboxEgressForwardedRequest(request) {
+  return Boolean(
+    request.headers.get(OIDC_TOKEN_HEADER)?.trim() && request.headers.get(FORWARDED_HOST_HEADER)?.trim() && request.headers.get(FORWARDED_SCHEME_HEADER)?.trim()
+  );
+}
+async function proxySandboxEgressRequest(request, deps = {}) {
   const oidcToken = request.headers.get(OIDC_TOKEN_HEADER)?.trim();
   if (!oidcToken) {
     return jsonError("Missing Vercel Sandbox OIDC token", 401);
   }
+  let oidcPayload;
   try {
-    await (deps.verifyOidc ?? verifyVercelSandboxOidcToken)(
-      oidcToken,
-      egressId
+    oidcPayload = await (deps.verifyOidc ?? verifyVercelSandboxOidcToken)(
+      oidcToken
     );
   } catch (error) {
     logWarn(
@@ -15084,24 +15671,101 @@ async function proxySandboxEgressRequest(request, egressId, deps = {}) {
     );
     return jsonError("Invalid Vercel Sandbox OIDC token", 401);
   }
-  const upstreamResult = buildUpstreamUrl(request, egressId);
+  const activeEgressId = sandboxIdFromPayload(oidcPayload);
+  if (!activeEgressId) {
+    logWarn(
+      "sandbox_egress_oidc_session_missing",
+      {},
+      {
+        "http.request.method": request.method,
+        "url.path": new URL(request.url).pathname
+      },
+      "Sandbox egress OIDC payload did not include a VM session id"
+    );
+    return jsonError(
+      "Vercel Sandbox OIDC token did not include sandbox_id",
+      401
+    );
+  }
+  const upstreamResult = buildUpstreamUrl(request);
   if (!upstreamResult.ok) {
+    logWarn(
+      "sandbox_egress_upstream_url_invalid",
+      {},
+      {
+        ...egressAttributes({
+          egressId: activeEgressId,
+          method: request.method,
+          path: new URL(request.url).pathname,
+          status: 400
+        }),
+        ...routingAttributes(request)
+      },
+      "Sandbox egress forwarded request had invalid upstream routing headers"
+    );
     return jsonError(upstreamResult.error, 400);
   }
   const upstreamUrl = upstreamResult.url;
   const provider = resolveSandboxEgressProviderForHost(upstreamUrl.hostname);
   if (!provider) {
+    logWarn(
+      "sandbox_egress_provider_unresolved",
+      {},
+      {
+        ...egressAttributes({
+          egressId: activeEgressId,
+          host: upstreamUrl.hostname,
+          method: request.method,
+          path: upstreamUrl.pathname,
+          status: 403
+        }),
+        ...routingAttributes(request, upstreamUrl)
+      },
+      "Sandbox egress forwarded host is not owned by any credential provider"
+    );
     return jsonError("No provider owns forwarded host", 403);
   }
-  const session = await getSandboxEgressSession(egressId);
+  const session = await getSandboxEgressSession(activeEgressId);
   if (!session) {
+    logWarn(
+      "sandbox_egress_session_unauthorized",
+      {},
+      {
+        ...egressAttributes({
+          egressId: activeEgressId,
+          host: upstreamUrl.hostname,
+          method: request.method,
+          path: upstreamUrl.pathname,
+          provider,
+          status: 403
+        }),
+        ...routingAttributes(request, upstreamUrl)
+      },
+      "Sandbox egress VM session is not authorized for requester credentials"
+    );
     return jsonError("Sandbox egress session is not authorized", 403);
   }
   let lease;
   try {
-    lease = await credentialLease(egressId, provider, session);
+    lease = await credentialLease(activeEgressId, provider, session);
   } catch (error) {
     if (error instanceof CredentialUnavailableError) {
+      logWarn(
+        "sandbox_egress_credential_unavailable",
+        {},
+        {
+          ...egressAttributes({
+            egressId: activeEgressId,
+            host: upstreamUrl.hostname,
+            method: request.method,
+            path: upstreamUrl.pathname,
+            provider,
+            status: 401
+          }),
+          ...routingAttributes(request, upstreamUrl)
+        },
+        "Sandbox egress provider credential is unavailable"
+      );
       return new Response(
         `junior-auth-required provider=${error.provider} 401 unauthorized
 ${error.message}`,
@@ -15114,85 +15778,94 @@ ${error.message}`,
     throw error;
   }
   if (!hasTransformForHost(lease, upstreamUrl.hostname)) {
-    return jsonError("Credential lease does not cover forwarded host", 403);
-  }
-  const body = await requestBodyBytes(request);
-  const upstream = await (deps.fetch ?? fetch)(upstreamUrl, {
-    method: request.method,
-    headers: requestHeaders(request, lease, upstreamUrl.hostname),
-    ...body ? { body } : {},
-    redirect: "manual"
-  });
-  if (AUTH_REJECTION_STATUS.has(upstream.status)) {
     logWarn(
-      "sandbox_egress_upstream_auth_rejected",
+      "sandbox_egress_transform_missing",
       {},
       {
-        "app.credential.provider": provider,
-        "http.request.method": request.method,
-        "http.response.status_code": upstream.status,
-        "server.address": upstreamUrl.hostname
+        ...egressAttributes({
+          egressId: activeEgressId,
+          host: upstreamUrl.hostname,
+          method: request.method,
+          path: upstreamUrl.pathname,
+          provider,
+          status: 403
+        }),
+        "app.sandbox.egress.transform_domains": lease.headerTransforms.map(
+          (transform) => transform.domain
+        ),
+        ...routingAttributes(request, upstreamUrl)
       },
-      "Sandbox egress upstream auth rejected"
+      "Sandbox egress credential lease does not cover forwarded host"
     );
-    await clearSandboxEgressCredentialLease(egressId, provider, session);
-  }
-  return new Response(upstream.body, {
-    status: upstream.status,
-    statusText: upstream.statusText,
-    headers: responseHeaders(upstream)
-  });
-}
-
-// src/handlers/sandbox-egress-proxy.ts
-async function ALL(request, egressId) {
-  return await proxySandboxEgressRequest(request, egressId);
-}
-
-// src/chat/slack/context.ts
-function toTrimmedSlackString(value) {
-  const normalized = toOptionalString(value);
-  return normalized?.trim() || void 0;
-}
-function parseSlackThreadId(threadId) {
-  const normalizedThreadId = toTrimmedSlackString(threadId);
-  if (!normalizedThreadId) {
-    return void 0;
-  }
-  const parts = normalizedThreadId.split(":");
-  if (parts.length !== 3 || parts[0] !== "slack") {
-    return void 0;
-  }
-  const channelId = toTrimmedSlackString(parts[1]);
-  const threadTs = toTrimmedSlackString(parts[2]);
-  if (!channelId || !threadTs) {
-    return void 0;
-  }
-  return { channelId, threadTs };
-}
-function resolveSlackChannelIdFromThreadId(threadId) {
-  return parseSlackThreadId(threadId)?.channelId;
-}
-function resolveSlackChannelIdFromMessage(message) {
-  const messageChannelId = toTrimmedSlackString(
-    message.channelId
-  );
-  if (messageChannelId) {
-    return messageChannelId;
+    return jsonError("Credential lease does not cover forwarded host", 403);
   }
-  const raw = message.raw;
-  if (raw && typeof raw === "object") {
-    const rawChannel = toTrimmedSlackString(
-      raw.channel
+  const body = await requestBodyBytes(request);
+  const fetchImpl = deps.fetch ?? fetch;
+  const headers = requestHeaders(request, lease, upstreamUrl.hostname);
+  const upstream = await fetchImpl(upstreamUrl, {
+    method: request.method,
+    headers,
+    ...body !== void 0 ? { body } : {},
+    redirect: "manual"
+  });
+  logSandboxEgressUpstreamRequest({
+    egressId: activeEgressId,
+    provider,
+    request,
+    upstream,
+    upstreamUrl
+  });
+  if (upstream.status >= 400) {
+    logWarn(
+      "sandbox_egress_upstream_error_response",
+      {},
+      {
+        ...egressAttributes({
+          egressId: activeEgressId,
+          host: upstreamUrl.hostname,
+          method: request.method,
+          path: upstreamUrl.pathname,
+          provider,
+          status: upstream.status
+        }),
+        ...routingAttributes(request, upstreamUrl),
+        "error.type": `http_${upstream.status}`
+      },
+      `Sandbox egress upstream returned HTTP ${upstream.status}`
     );
-    if (rawChannel) {
-      return rawChannel;
-    }
   }
-  const threadId = toTrimmedSlackString(
-    message.threadId
-  );
-  return resolveSlackChannelIdFromThreadId(threadId);
+  if (AUTH_REJECTION_STATUS.has(upstream.status)) {
+    logWarn(
+      "sandbox_egress_upstream_auth_rejected",
+      {},
+      {
+        ...egressAttributes({
+          egressId: activeEgressId,
+          host: upstreamUrl.hostname,
+          method: request.method,
+          path: upstreamUrl.pathname,
+          provider,
+          status: upstream.status
+        }),
+        ...routingAttributes(request, upstreamUrl)
+      },
+      "Sandbox egress upstream auth rejected"
+    );
+    await clearSandboxEgressCredentialLease(activeEgressId, provider, session);
+  }
+  return new Response(upstream.body, {
+    status: upstream.status,
+    statusText: upstream.statusText,
+    headers: responseHeaders(upstream)
+  });
+}
+
+// src/handlers/sandbox-egress-proxy.ts
+async function ALL(request) {
+  return await proxySandboxEgressRequest(request);
+}
+function isSandboxEgressRequest(request) {
+  return isSandboxEgressForwardedRequest(request);
 }
 
 // src/handlers/turn-resume.ts
@@ -15487,11 +16160,11 @@ var DIRECTED_FOLLOW_UP_CUE_RE = /\b(?:you said|you just said|your last response|
 var TERSE_CLARIFICATION_RE = /^(?:which one|which ones|why|how so|what do you mean|what did you mean|say more|explain that|clarify that|expand on that|elaborate on that)\??$/i;
 var GENERIC_IMMEDIATE_SIDE_CONVERSATION_RE = /^(?:is that (?:the )?right (?:approach|call|move)|(?:can|could|would) you check on this)\??$/i;
 var RECENT_THREAD_WINDOW = 6;
-function escapeRegExp2(value) {
+function escapeRegExp3(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function containsAssistantInvocation(text, botUserName) {
-  const escapedUserName = escapeRegExp2(botUserName);
+  const escapedUserName = escapeRegExp3(botUserName);
   const plainNameMentionRe = new RegExp(`(^|\\s)@${escapedUserName}\\b`, "i");
   const labeledEntityMentionRe = new RegExp(
     `<@[^>|]+\\|${escapedUserName}>`,
@@ -15786,187 +16459,6 @@ async function decideSubscribedThreadReply(args) {
   }
 }
 
-// src/chat/slack/errors.ts
-function getSlackApiErrorCode(error) {
-  if (!error || typeof error !== "object") {
-    return void 0;
-  }
-  const candidate = error;
-  if (typeof candidate.data?.error === "string" && candidate.data.error.trim().length > 0) {
-    return candidate.data.error;
-  }
-  if (typeof candidate.code === "string" && candidate.code.trim().length > 0) {
-    return candidate.code;
-  }
-  return void 0;
-}
-function getSlackErrorObservabilityAttributes(error) {
-  if (!error || typeof error !== "object") {
-    return {};
-  }
-  const candidate = error;
-  const attributes = {};
-  if (typeof candidate.code === "string" && candidate.code.trim().length > 0) {
-    attributes["app.slack.error_code"] = candidate.code;
-  }
-  if (typeof candidate.data?.error === "string" && candidate.data.error.trim().length > 0) {
-    attributes["app.slack.api_error"] = candidate.data.error;
-  }
-  const requestId = getHeaderString(candidate.headers, "x-slack-req-id");
-  if (requestId) {
-    attributes["app.slack.request_id"] = requestId;
-  }
-  if (typeof candidate.statusCode === "number" && Number.isFinite(candidate.statusCode)) {
-    attributes["http.response.status_code"] = candidate.statusCode;
-  }
-  return attributes;
-}
-function isSlackTitlePermissionError(error) {
-  const code = getSlackApiErrorCode(error);
-  return code === "no_permission" || code === "missing_scope" || code === "not_allowed_token_type";
-}
-
-// src/chat/runtime/thread-context.ts
-function escapeRegExp3(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function stripLeadingBotMention(text, options = {}) {
-  if (!text.trim()) return text;
-  let next = text;
-  if (options.stripLeadingSlackMentionToken) {
-    next = next.replace(/^\s*<@[^>]+>[\s,:-]*/, "").trim();
-  }
-  const mentionByNameRe = new RegExp(
-    `^\\s*@${escapeRegExp3(botConfig.userName)}\\b[\\s,:-]*`,
-    "i"
-  );
-  next = next.replace(mentionByNameRe, "").trim();
-  const mentionByLabeledEntityRe = new RegExp(
-    `^\\s*<@[^>|]+\\|${escapeRegExp3(botConfig.userName)}>[\\s,:-]*`,
-    "i"
-  );
-  next = next.replace(mentionByLabeledEntityRe, "").trim();
-  return next;
-}
-function getThreadId(thread, _message) {
-  return toOptionalString(thread.id);
-}
-function getRunId(thread, message) {
-  return toOptionalString(thread.runId) ?? toOptionalString(message.runId);
-}
-function getChannelId(thread, message) {
-  return resolveSlackChannelIdFromThreadId(toOptionalString(thread.id)) ?? normalizeSlackConversationId(toOptionalString(thread.channelId)) ?? resolveSlackChannelIdFromMessage(message);
-}
-function getThreadTs(threadId) {
-  return parseSlackThreadId(threadId)?.threadTs;
-}
-function getAssistantThreadContext(message) {
-  const raw = message.raw;
-  const rawRecord = raw && typeof raw === "object" ? raw : void 0;
-  const channelId = toOptionalString(rawRecord?.channel);
-  if (channelId) {
-    const rawThreadTs = toOptionalString(rawRecord?.thread_ts);
-    const threadTs = isDmChannel(channelId) ? rawThreadTs : rawThreadTs ?? toOptionalString(rawRecord?.ts);
-    if (threadTs) {
-      return { channelId, threadTs };
-    }
-  }
-  const parsedThreadId = parseSlackThreadId(
-    toOptionalString(message.threadId)
-  );
-  if (!parsedThreadId || isDmChannel(parsedThreadId.channelId)) {
-    return void 0;
-  }
-  return parsedThreadId;
-}
-function getMessageTs(message) {
-  const directTs = toOptionalString(
-    message.ts
-  );
-  if (directTs) {
-    return directTs;
-  }
-  const raw = message.raw;
-  if (!raw || typeof raw !== "object") {
-    return void 0;
-  }
-  const rawRecord = raw;
-  return toOptionalString(rawRecord.ts) ?? toOptionalString(rawRecord.event_ts) ?? toOptionalString(rawRecord.message?.ts);
-}
-
-// src/chat/runtime/processing-reaction.ts
-var PROCESSING_REACTION_EMOJI = "eyes";
-var noProcessingReaction = {
-  keep: () => void 0,
-  stop: async () => void 0
-};
-function isProcessingReactionEmoji(value) {
-  return typeof value === "string" && normalizeSlackEmojiName(value) === PROCESSING_REACTION_EMOJI;
-}
-function shouldKeepProcessingReactionForToolInvocation(input) {
-  return input.toolName === "slackMessageAddReaction" && isProcessingReactionEmoji(input.params.emoji);
-}
-async function startSlackProcessingReaction(args) {
-  if (args.message.author.isMe) {
-    return noProcessingReaction;
-  }
-  const channelId = getChannelId(args.thread, args.message);
-  const messageTs = getMessageTs(args.message);
-  if (!channelId || !messageTs) {
-    return noProcessingReaction;
-  }
-  try {
-    await addReactionToMessage({
-      channelId,
-      timestamp: messageTs,
-      emoji: PROCESSING_REACTION_EMOJI
-    });
-  } catch (error) {
-    args.logException(
-      error,
-      "slack_processing_reaction_add_failed",
-      args.logContext,
-      {
-        "app.slack.action": "reactions.add",
-        "messaging.message.id": messageTs,
-        ...getSlackErrorObservabilityAttributes(error)
-      },
-      "Failed to add Slack processing reaction"
-    );
-    return noProcessingReaction;
-  }
-  let shouldRemove = true;
-  return {
-    keep: () => {
-      shouldRemove = false;
-    },
-    stop: async () => {
-      if (!shouldRemove) {
-        return;
-      }
-      try {
-        await removeReactionFromMessage({
-          channelId,
-          timestamp: messageTs,
-          emoji: PROCESSING_REACTION_EMOJI
-        });
-      } catch (error) {
-        args.logException(
-          error,
-          "slack_processing_reaction_remove_failed",
-          args.logContext,
-          {
-            "app.slack.action": "reactions.remove",
-            "messaging.message.id": messageTs,
-            ...getSlackErrorObservabilityAttributes(error)
-          },
-          "Failed to remove Slack processing reaction"
-        );
-      }
-    }
-  };
-}
-
 // src/chat/runtime/slack-runtime.ts
 var THREAD_OPTOUT_ACK = "Understood. I'll stay out of this thread unless someone @mentions me again.";
 async function maybeHandleThreadOptOutDecision(args) {
@@ -16131,24 +16623,14 @@ function createSlackTurnRuntime(deps) {
         const threadId = deps.getThreadId(thread, message);
         const channelId = deps.getChannelId(thread, message);
         const runId = deps.getRunId(thread, message);
-        const context = logContext({
+        const turnContext = logContext({
           threadId,
           requesterId: message.author.userId,
           requesterUserName: message.author.userName,
           channelId,
           runId
         });
-        processingReaction = await startSlackProcessingReaction({
-          thread,
-          message,
-          logException: deps.logException,
-          logContext: context
-        });
-        const toolInvocationHook = createToolInvocationHook(
-          processingReaction,
-          hooks
-        );
-        await deps.withSpan("chat.turn", "chat.turn", context, async () => {
+        await deps.withSpan("chat.turn", "chat.turn", turnContext, async () => {
           const legacyAttachmentText = renderSlackLegacyAttachmentText(
             message.raw
           );
@@ -16163,7 +16645,7 @@ function createSlackTurnRuntime(deps) {
             strippedUserText,
             message.raw
           );
-          const context2 = {
+          const threadContext = {
             threadId,
             requesterId: message.author.userId,
             channelId,
@@ -16181,7 +16663,7 @@ function createSlackTurnRuntime(deps) {
               thread,
               message,
               decision: { shouldReply: false, reason },
-              context: context2,
+              context: threadContext,
               userText
             });
             return;
@@ -16191,7 +16673,7 @@ function createSlackTurnRuntime(deps) {
             message,
             userText,
             explicitMention: Boolean(message.isMention),
-            context: context2
+            context: threadContext
           });
           await deps.persistPreparedState({
             thread,
@@ -16203,7 +16685,7 @@ function createSlackTurnRuntime(deps) {
             conversationContext: deps.getPreparedConversationContext(preparedState),
             hasAttachments: message.attachments.length > 0 || legacyAttachmentText !== "",
             isExplicitMention: Boolean(message.isMention),
-            context: context2
+            context: threadContext
           });
           if (await maybeHandleThreadOptOutDecision({
             thread,
@@ -16214,7 +16696,7 @@ function createSlackTurnRuntime(deps) {
               thread,
               message,
               decision,
-              context: context2,
+              context: threadContext,
               preparedState,
               userText
             });
@@ -16225,12 +16707,22 @@ function createSlackTurnRuntime(deps) {
               thread,
               message,
               decision,
-              context: context2,
+              context: threadContext,
               preparedState,
               userText
             });
             return;
           }
+          processingReaction = await startSlackProcessingReaction({
+            thread,
+            message,
+            logException: deps.logException,
+            logContext: turnContext
+          });
+          const toolInvocationHook = createToolInvocationHook(
+            processingReaction,
+            hooks
+          );
           await deps.replyToThread(thread, message, {
             explicitMention: Boolean(message.isMention),
             preparedState,
@@ -16988,8 +17480,14 @@ function createJuniorRuntimeServices(overrides = {}) {
 }
 
 // src/chat/slack/message.ts
+function isSlackMessageTs(value) {
+  return /^\d+(?:\.\d+)?$/.test(value.trim());
+}
 function getSlackMessageTs(message) {
-  if (message.id.endsWith(":message_changed_mention") && message.raw && typeof message.raw === "object") {
+  if (isSlackMessageTs(message.id)) {
+    return message.id;
+  }
+  if (message.raw && typeof message.raw === "object") {
     const ts = message.raw.ts;
     if (typeof ts === "string" && ts.length > 0) {
       return ts;
@@ -17152,6 +17650,26 @@ function createReplyToThread(deps) {
             throw error;
           }
         };
+        const postAuthPauseNotice = async () => {
+          try {
+            await beforeFirstResponsePost();
+            await thread.post(
+              buildSlackOutputMessage(buildAuthPauseResponse())
+            );
+          } catch (error) {
+            logException(
+              error,
+              "slack_auth_pause_notice_post_failed",
+              turnTraceContext,
+              {
+                "app.slack.reply_stage": "thread_reply_auth_pause_notice",
+                ...messageTs ? { "messaging.message.id": messageTs } : {},
+                ...getSlackErrorObservabilityAttributes(error)
+              },
+              "Failed to post auth pause notice"
+            );
+          }
+        };
         const activeTurnId = preparedState.conversation.processing.activeTurnId;
         if (conversationId && activeTurnId) {
           const resumeRequest = await deps.services.getAwaitingTurnContinuationRequest({
@@ -17466,6 +17984,7 @@ function createReplyToThread(deps) {
           }
         } catch (error) {
           if (isRetryableTurnError(error, "mcp_auth_resume") || isRetryableTurnError(error, "plugin_auth_resume")) {
+            await postAuthPauseNotice();
             completeAuthPauseTurn({
               conversation: preparedState.conversation,
               sessionId: error.metadata?.sessionId ?? turnId
@@ -18692,6 +19211,12 @@ async function createApp(options) {
     logException(err, "unhandled_route_error");
     return c.text("Internal Server Error", 500);
   });
+  app.use("*", async (c, next) => {
+    if (isSandboxEgressRequest(c.req.raw)) {
+      return await ALL(c.req.raw);
+    }
+    await next();
+  });
   app.get("/", () => GET3());
   app.get("/health", () => GET2());
   app.get("/api/info", () => GET());
@@ -18704,12 +19229,6 @@ async function createApp(options) {
   app.post("/api/internal/turn-resume", (c) => {
     return POST(c.req.raw, waitUntil);
   });
-  app.all("/api/internal/sandbox-egress/:egressId", (c) => {
-    return ALL(c.req.raw, c.req.param("egressId"));
-  });
-  app.all("/api/internal/sandbox-egress/:egressId/*", (c) => {
-    return ALL(c.req.raw, c.req.param("egressId"));
-  });
   app.post("/api/webhooks/:platform", (c) => {
     return POST2(c.req.raw, c.req.param("platform"), waitUntil);
   });