npm - @sentry/junior - Versions diffs - 0.19.0 → 0.21.0 - Mend

@sentry/junior 0.19.0 → 0.21.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/dist/app.js +1712 -911
package/dist/{chunk-DTOS5CG4.js → chunk-N4ICA2BC.js} +59 -8
package/dist/{chunk-4XWTSMRF.js → chunk-NRSP2MLC.js} +2 -3
package/dist/{chunk-RBB2MZAN.js → chunk-XPXD3FCE.js} +23 -5
package/dist/{chunk-XYOKYK6U.js → chunk-Z43DS7XN.js} +11 -2
package/dist/cli/check.js +60 -3
package/dist/cli/init.js +9 -3
package/dist/cli/snapshot-warmup.js +3 -3
package/dist/nitro.js +1 -1
package/package.json +1 -1

package/dist/app.js CHANGED Viewed

@@ -5,10 +5,10 @@ import {
   listCapabilityProviders,
   loadSkillsByName,
   logCapabilityCatalogLoadedOnce,
-  parseSkillInvocation,
-  stripFrontmatter
-} from "./chunk-4XWTSMRF.js";
+  parseSkillInvocation
+} from "./chunk-NRSP2MLC.js";
 import {
+  SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
   SANDBOX_WORKSPACE_ROOT,
   botConfig,
@@ -25,8 +25,9 @@ import {
   resolveRuntimeDependencySnapshot,
   runNonInteractiveCommand,
   sandboxSkillDir,
+  sandboxSkillFile,
   toOptionalTrimmed
-} from "./chunk-XYOKYK6U.js";
+} from "./chunk-Z43DS7XN.js";
 import {
   CredentialUnavailableError,
   buildOAuthTokenRequest,
@@ -38,6 +39,7 @@ import {
   getPluginMcpProviders,
   getPluginOAuthConfig,
   getPluginProviders,
+  hasRequiredOAuthScope,
   isPluginProvider,
   isRecord,
   logError,
@@ -55,15 +57,16 @@ import {
   toOptionalString,
   withContext,
   withSpan
-} from "./chunk-DTOS5CG4.js";
+} from "./chunk-N4ICA2BC.js";
 import "./chunk-Z3YD6NHK.js";
 import {
-  aboutPathCandidates,
   discoverInstalledPluginPackageContent,
   homeDir,
+  listReferenceFiles,
   setPluginPackages,
-  soulPathCandidates
-} from "./chunk-RBB2MZAN.js";
+  soulPathCandidates,
+  worldPathCandidates
+} from "./chunk-XPXD3FCE.js";
 import "./chunk-2KG3PWR4.js";
 // src/app.ts
@@ -72,9 +75,12 @@ import { Hono } from "hono";
 // src/handlers/diagnostics.ts
 import { readFileSync } from "fs";
 import path from "path";
-function readAboutText() {
+function readDescriptionText() {
   try {
-    const raw = readFileSync(path.join(homeDir(), "ABOUT.md"), "utf8").trim();
+    const raw = readFileSync(
+      path.join(homeDir(), "DESCRIPTION.md"),
+      "utf8"
+    ).trim();
     return raw || void 0;
   } catch {
     return void 0;
@@ -86,7 +92,7 @@ async function GET() {
   return Response.json({
     cwd: process.cwd(),
     homeDir: homeDir(),
-    aboutText: readAboutText(),
+    descriptionText: readDescriptionText(),
     providers: getPluginProviders().map((plugin) => plugin.manifest.name),
     skills: skills.map((skill) => ({
       name: skill.name,
@@ -198,9 +204,9 @@ async function GET3() {
 </head>
 <body>
   <h1>&gt; junior</h1>`;
-  if (d?.aboutText) {
+  if (d?.descriptionText) {
     html += `
-  <div class="subtitle">${escapeXml(String(d.aboutText))}</div>`;
+  <div class="subtitle">${escapeXml(String(d.descriptionText))}</div>`;
   }
   html += `
   <div class="section">
@@ -2298,6 +2304,17 @@ async function completeObject(params) {
   };
 }
+// src/chat/slack/message.ts
+function getSlackMessageTs(message) {
+  if (message.id.endsWith(":message_changed_mention") && message.raw && typeof message.raw === "object") {
+    const ts = message.raw.ts;
+    if (typeof ts === "string" && ts.length > 0) {
+      return ts;
+    }
+  }
+  return message.id;
+}
 // src/chat/services/conversation-memory.ts
 var CONTEXT_COMPACTION_TRIGGER_TOKENS = 9e3;
 var CONTEXT_COMPACTION_TARGET_TOKENS = 7e3;
@@ -2572,7 +2589,7 @@ function createConversationMessageFromSdkMessage(entry) {
       isBot: typeof entry.author.isBot === "boolean" ? entry.author.isBot : void 0
     },
     meta: {
-      slackTs: entry.id
+      slackTs: getSlackMessageTs(entry)
     }
   };
 }
@@ -2651,6 +2668,7 @@ import { Agent } from "@mariozechner/pi-agent-core";
 // src/chat/prompt.ts
 import fs from "fs";
+import path2 from "path";
 var DEFAULT_SOUL = "You are Junior, a practical and concise assistant.";
 function getLoggedMarkdownFiles() {
   const globalState = globalThis;
@@ -2698,8 +2716,8 @@ function loadSoul() {
   );
   return DEFAULT_SOUL;
 }
-function loadAbout() {
-  return loadOptionalMarkdownFile(aboutPathCandidates(), "ABOUT.md");
+function loadWorld() {
+  return loadOptionalMarkdownFile(worldPathCandidates(), "WORLD.md");
 }
 var JUNIOR_PERSONALITY = (() => {
   try {
@@ -2716,17 +2734,17 @@ var JUNIOR_PERSONALITY = (() => {
     return DEFAULT_SOUL;
   }
 })();
-var JUNIOR_ABOUT = (() => {
+var JUNIOR_WORLD = (() => {
   try {
-    return loadAbout();
+    return loadWorld();
   } catch (error) {
     logWarn(
-      "about_load_failed",
+      "world_load_failed",
       {},
       {
         "error.message": error instanceof Error ? error.message : String(error)
       },
-      "Failed to load ABOUT.md; omitting about prompt context"
+      "Failed to load WORLD.md; omitting world prompt context"
     );
     return null;
   }
@@ -2846,6 +2864,25 @@ function baseSystemPrompt() {
     "- When active skills are present, follow their instructions before default behavior."
   ].join("\n");
 }
+function formatReferenceFilesSection() {
+  const files = listReferenceFiles();
+  if (files.length === 0) {
+    return [];
+  }
+  const fileNames = files.map((filePath) => {
+    const name = path2.basename(filePath);
+    return `- ${escapeXml(name)} (${escapeXml(`${SANDBOX_DATA_ROOT}/${name}`)})`;
+  });
+  return [
+    renderTag(
+      "reference-files",
+      [
+        "Additional reference documents available in the sandbox. Read them with `readFile` when relevant.",
+        ...fileNames
+      ].join("\n")
+    )
+  ];
+}
 function buildSystemPrompt(params) {
   const {
     availableSkills,
@@ -2857,7 +2894,8 @@ function buildSystemPrompt(params) {
     artifactState,
     configuration,
     relevantConfigurationKeys,
-    runtimeMetadata
+    runtimeMetadata,
+    threadParticipants
   } = params;
   const assistantSection = renderIdentityBlock("assistant", {
     user_name: assistant?.userName ?? botConfig.userName,
@@ -2913,22 +2951,43 @@ function buildSystemPrompt(params) {
         JUNIOR_PERSONALITY.trim()
       ].join("\n")
     ),
-    ...JUNIOR_ABOUT ? [
+    ...JUNIOR_WORLD ? [
       renderTag(
-        "about",
+        "world",
         [
-          "Use this as the assistant's product/domain description when relevant.",
+          "Use this as the assistant's operational/domain context.",
           "",
-          JUNIOR_ABOUT.trim()
+          JUNIOR_WORLD.trim()
         ].join("\n")
       )
     ] : [],
+    ...formatReferenceFilesSection(),
     renderTag(
       "identity-context",
       [
         "Use these blocks as authoritative metadata for identity questions.",
         assistantSection,
-        requesterSection
+        requesterSection,
+        ...threadParticipants && threadParticipants.length > 0 ? [
+          renderTag(
+            "thread-participants",
+            [
+              "Known participants in this thread. When you mention one of these people, use the provided Slack mention token exactly as `<@USERID>` and do not write a bare `@name` form.",
+              ...threadParticipants.map((p) => {
+                const parts = [];
+                if (p.userId) {
+                  parts.push(`user_id: ${escapeXml(p.userId)}`);
+                  parts.push(`slack_mention: <@${p.userId}>`);
+                }
+                if (p.userName)
+                  parts.push(`user_name: ${escapeXml(p.userName)}`);
+                if (p.fullName)
+                  parts.push(`full_name: ${escapeXml(p.fullName)}`);
+                return `- ${parts.join(", ")}`;
+              })
+            ].join("\n")
+          )
+        ] : []
       ].join("\n")
     ),
     renderTag(
@@ -3827,7 +3886,8 @@ async function handleOAuthStartCommand(args, deps) {
   }
   if (deps.requesterId && deps.userTokenStore) {
     const stored = await deps.userTokenStore.get(deps.requesterId, provider);
-    if (stored && (stored.expiresAt === void 0 || stored.expiresAt > Date.now())) {
+    const providerConfig = getPluginOAuthConfig(provider);
+    if (stored && (stored.expiresAt === void 0 || stored.expiresAt > Date.now()) && hasRequiredOAuthScope(stored.scope, providerConfig?.scope)) {
       const providerLabel = formatProviderLabel(provider);
       return commandResult({
         stdout: {
@@ -3982,12 +4042,12 @@ async function maybeExecuteJrRpcCustomCommand(command, deps) {
 // src/chat/sandbox/skill-sandbox.ts
 import fs2 from "fs/promises";
-import path2 from "path";
+import path3 from "path";
 var MAX_SKILL_FILE_BYTES = 256 * 1024;
 var DEFAULT_MAX_SKILL_FILE_CHARS = 2e4;
 var DEFAULT_MAX_SKILL_LIST_ENTRIES = 200;
 function normalizePathForOutput(value) {
-  return value.split(path2.sep).join("/");
+  return value.split(path3.sep).join("/");
 }
 function normalizeSkillName(value) {
   return value.trim().toLowerCase();
@@ -3996,12 +4056,12 @@ function resolvePathWithinRoot(root, relativePath) {
   if (!relativePath.trim()) {
     throw new Error("Path must not be empty.");
   }
-  if (path2.isAbsolute(relativePath)) {
+  if (path3.isAbsolute(relativePath)) {
     throw new Error("Absolute paths are not allowed.");
   }
-  const resolvedRoot = path2.resolve(root);
-  const resolvedPath = path2.resolve(resolvedRoot, relativePath);
-  if (resolvedPath !== resolvedRoot && !resolvedPath.startsWith(`${resolvedRoot}${path2.sep}`)) {
+  const resolvedRoot = path3.resolve(root);
+  const resolvedPath = path3.resolve(resolvedRoot, relativePath);
+  if (resolvedPath !== resolvedRoot && !resolvedPath.startsWith(`${resolvedRoot}${path3.sep}`)) {
     throw new Error("Path escapes the skill directory.");
   }
   return resolvedPath;
@@ -4081,7 +4141,7 @@ var SkillSandbox = class {
       1,
       Math.min(params.maxEntries ?? DEFAULT_MAX_SKILL_LIST_ENTRIES, 1e3)
     );
-    const root = path2.resolve(skill.skillPath);
+    const root = path3.resolve(skill.skillPath);
     const targetDirectory = resolvePathWithinRoot(root, directory);
     const targetStats = await fs2.stat(targetDirectory);
     if (!targetStats.isDirectory()) {
@@ -4097,9 +4157,9 @@ var SkillSandbox = class {
       });
       children.sort((a, b) => a.name.localeCompare(b.name));
       for (const child of children) {
-        const absolutePath = path2.join(currentDirectory, child.name);
+        const absolutePath = path3.join(currentDirectory, child.name);
         const relativePath = normalizePathForOutput(
-          path2.relative(root, absolutePath)
+          path3.relative(root, absolutePath)
         );
         if (!relativePath || relativePath.startsWith("..")) {
           continue;
@@ -4122,7 +4182,7 @@ var SkillSandbox = class {
       }
     }
     const relativeDirectory = normalizePathForOutput(
-      path2.relative(root, targetDirectory) || "."
+      path3.relative(root, targetDirectory) || "."
     );
     return {
       skillName: skill.name,
@@ -4137,7 +4197,7 @@ var SkillSandbox = class {
       1,
       Math.min(params.maxChars ?? DEFAULT_MAX_SKILL_FILE_CHARS, 1e5)
     );
-    const root = path2.resolve(skill.skillPath);
+    const root = path3.resolve(skill.skillPath);
     const targetPath = resolvePathWithinRoot(root, params.filePath);
     const stats = await fs2.stat(targetPath);
     if (!stats.isFile()) {
@@ -4152,7 +4212,7 @@ var SkillSandbox = class {
     const truncated = raw.length > maxChars;
     return {
       skillName: skill.name,
-      path: normalizePathForOutput(path2.relative(root, targetPath)),
+      path: normalizePathForOutput(path3.relative(root, targetPath)),
       content: truncated ? raw.slice(0, maxChars) : raw,
       truncated
     };
@@ -4726,7 +4786,7 @@ function createBashTool() {
 }
 // src/chat/tools/sandbox/attach-file.ts
-import path3 from "path";
+import path4 from "path";
 import { Type as Type2 } from "@sinclair/typebox";
 var MAX_ATTACH_FILE_BYTES = 10 * 1024 * 1024;
 var MIME_BY_EXTENSION = {
@@ -4748,20 +4808,20 @@ function normalizeSandboxPath(inputPath) {
   if (!trimmed) {
     throw new Error("path is required");
   }
-  if (path3.posix.isAbsolute(trimmed)) {
+  if (path4.posix.isAbsolute(trimmed)) {
     return trimmed;
   }
-  return path3.posix.join(SANDBOX_WORKSPACE_ROOT, trimmed);
+  return path4.posix.join(SANDBOX_WORKSPACE_ROOT, trimmed);
 }
 function sanitizeFilename(value, fallbackPath) {
   const candidate = (value ?? "").trim();
   if (candidate) {
-    const base = path3.posix.basename(candidate);
+    const base = path4.posix.basename(candidate);
     if (base && base !== "." && base !== "..") {
       return base;
     }
   }
-  const derived = path3.posix.basename(fallbackPath);
+  const derived = path4.posix.basename(fallbackPath);
   if (derived && derived !== "." && derived !== "..") {
     return derived;
   }
@@ -4772,7 +4832,7 @@ function inferMimeType(filename, explicitMimeType) {
   if (explicit) {
     return explicit;
   }
-  const ext = path3.extname(filename).toLowerCase();
+  const ext = path4.extname(filename).toLowerCase();
   return MIME_BY_EXTENSION[ext] ?? "application/octet-stream";
 }
 async function detectMimeType(sandbox, targetPath) {
@@ -4819,7 +4879,7 @@ function createAttachFileTool(sandbox, hooks = {}) {
       const fileBuffer = await sandbox.readFileToBuffer({ path: targetPath });
       if (!fileBuffer) {
         const generatedFile = hooks.getGeneratedFile?.(
-          path3.posix.basename(targetPath)
+          path4.posix.basename(targetPath)
         );
         if (generatedFile) {
           hooks.onGeneratedFiles?.([generatedFile]);
@@ -5021,7 +5081,7 @@ function toLoadedSkill(result, availableSkills) {
   return {
     name: result.skill_name,
     description: result.description,
-    skillPath: result.skill_dir,
+    skillPath: metadata?.skillPath ?? result.skill_dir,
     ...metadata?.pluginProvider ? { pluginProvider: metadata.pluginProvider } : {},
     ...metadata?.allowedTools ? { allowedTools: metadata.allowedTools } : {},
     ...metadata?.requiresCapabilities ? { requiresCapabilities: metadata.requiresCapabilities } : {},
@@ -5029,7 +5089,7 @@ function toLoadedSkill(result, availableSkills) {
     body: result.instructions
   };
 }
-async function loadSkillFromSandbox(sandbox, availableSkills, skillName) {
+async function loadSkillFromHost(availableSkills, skillName) {
   const requested = skillName.trim().toLowerCase();
   const skill = availableSkills.find(
     (entry) => entry.name.toLowerCase() === requested
@@ -5042,10 +5102,10 @@ async function loadSkillFromSandbox(sandbox, availableSkills, skillName) {
     };
   }
   const skillDir = sandboxSkillDir(skill.name);
-  const skillFilePath = `${skillDir}/SKILL.md`;
-  const file = await sandbox.readFileToBuffer({ path: skillFilePath });
-  if (!file) {
-    throw new Error(`failed to read ${skillFilePath}`);
+  const skillFilePath = sandboxSkillFile(skill.name);
+  const [loaded] = await loadSkillsByName([skill.name], availableSkills);
+  if (!loaded) {
+    throw new Error(`failed to load ${skill.name}`);
   }
   return {
     ok: true,
@@ -5054,10 +5114,10 @@ async function loadSkillFromSandbox(sandbox, availableSkills, skillName) {
     ...skill.requiresCapabilities ? { requires_capabilities: skill.requiresCapabilities } : {},
     skill_dir: skillDir,
     location: skillFilePath,
-    instructions: stripFrontmatter(file.toString("utf8"))
+    instructions: loaded.body
   };
 }
-function createLoadSkillTool(sandbox, availableSkills, options) {
+function createLoadSkillTool(availableSkills, options) {
   return tool({
     description: "Load a skill by name so its instructions are available for this turn. The result includes `requires_capabilities` when the skill declares authenticated provider access, and `available_tools` when the skill exposes MCP tools for this turn. Use when a request clearly matches a known skill. Do not use when no skill is relevant.",
     inputSchema: Type4.Object({
@@ -5067,11 +5127,7 @@ function createLoadSkillTool(sandbox, availableSkills, options) {
       })
     }),
     execute: async ({ skill_name }) => {
-      const result = await loadSkillFromSandbox(
-        sandbox,
-        availableSkills,
-        skill_name
-      );
+      const result = await loadSkillFromHost(availableSkills, skill_name);
       const loadedSkill = toLoadedSkill(result, availableSkills);
       if (loadedSkill) {
         const metadata = await options?.onSkillLoaded?.(loadedSkill);
@@ -6810,7 +6866,7 @@ function createToolState(hooks, context) {
 function createTools(availableSkills, hooks = {}, context) {
   const state = createToolState(hooks, context);
   const tools = {
-    loadSkill: createLoadSkillTool(context.sandbox, availableSkills, {
+    loadSkill: createLoadSkillTool(availableSkills, {
       onSkillLoaded: hooks.onSkillLoaded
     }),
     systemTime: createSystemTimeTool(),
@@ -6866,10 +6922,7 @@ function resolveChannelCapabilities(channelId) {
 }
 // src/chat/sandbox/sandbox.ts
-import fs3 from "fs/promises";
-import path4 from "path";
-import { Sandbox } from "@vercel/sandbox";
-import { createBashTool as createBashTool2 } from "bash-tool";
+import fs4 from "fs/promises";
 // src/chat/sandbox/http-error-details.ts
 var DEFAULT_PREVIEW_LIMIT = 512;
@@ -6973,6 +7026,109 @@ function extractHttpErrorDetails(error, options = {}) {
   };
 }
+// src/chat/sandbox/errors.ts
+var SANDBOX_ERROR_FIELDS = [
+  {
+    sourceKey: "sandboxId",
+    attributeKey: "sandbox_id",
+    summaryKey: "sandboxId"
+  }
+];
+function getSandboxErrorDetails(error) {
+  return extractHttpErrorDetails(error, {
+    attributePrefix: "app.sandbox.api_error",
+    extraFields: [...SANDBOX_ERROR_FIELDS]
+  });
+}
+function findInErrorChain(error, predicate) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current && !seen.has(current)) {
+    if (predicate(current)) {
+      return true;
+    }
+    seen.add(current);
+    current = typeof current === "object" ? current.cause : void 0;
+  }
+  return false;
+}
+function getFirstErrorMessage(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current && !seen.has(current)) {
+    if (current instanceof Error) {
+      const message = current.message.trim();
+      if (message) {
+        return message;
+      }
+    }
+    seen.add(current);
+    current = typeof current === "object" ? current.cause : void 0;
+  }
+  return void 0;
+}
+function isAlreadyExistsError(error) {
+  const details = getSandboxErrorDetails(error);
+  return details.searchableText.includes("already exists") || details.searchableText.includes("file exists") || details.searchableText.includes("eexist");
+}
+function isSandboxUnavailableError(error) {
+  return findInErrorChain(error, (candidate) => {
+    const details = getSandboxErrorDetails(candidate);
+    const searchable = `${details.searchableText} ${details.summary}`.toLowerCase();
+    return searchable.includes("sandbox_stopped") || searchable.includes("status=410") || searchable.includes("status code 410") || searchable.includes("no longer available");
+  });
+}
+function isSnapshottingError(error) {
+  return findInErrorChain(error, (candidate) => {
+    const details = getSandboxErrorDetails(candidate);
+    const searchable = `${details.searchableText} ${details.summary}`.toLowerCase();
+    return searchable.includes("sandbox_snapshotting") || searchable.includes("creating a snapshot") || searchable.includes("stopped shortly");
+  });
+}
+function wrapSandboxSetupError(error) {
+  try {
+    const details = getSandboxErrorDetails(error);
+    if (details.summary) {
+      return new Error(`sandbox setup failed (${details.summary})`, {
+        cause: error
+      });
+    }
+  } catch {
+  }
+  let causeMessage;
+  try {
+    causeMessage = getFirstErrorMessage(error);
+  } catch (cause) {
+    causeMessage = cause instanceof Error ? cause.message : void 0;
+  }
+  if (causeMessage && causeMessage.trim() && causeMessage !== "sandbox setup failed") {
+    const oneLine = causeMessage.replace(/\s+/g, " ").trim();
+    return new Error(`sandbox setup failed (${oneLine})`, { cause: error });
+  }
+  return new Error("sandbox setup failed", { cause: error });
+}
+function throwSandboxOperationError(action, error, includeMissingPath = false) {
+  const details = getSandboxErrorDetails(error);
+  setSpanAttributes({
+    ...details.attributes,
+    ...includeMissingPath ? {
+      "app.sandbox.api_error.missing_path": details.searchableText.includes("no such file") || details.searchableText.includes("enoent")
+    } : {},
+    "app.sandbox.success": false
+  });
+  setSpanStatus("error");
+  throw new Error(
+    details.summary ? `${action} failed (${details.summary})` : `${action} failed`,
+    {
+      cause: error
+    }
+  );
+}
+// src/chat/sandbox/session.ts
+import { Sandbox } from "@vercel/sandbox";
+import { createBashTool as createBashTool2 } from "bash-tool";
 // src/chat/runtime/status-format.ts
 var SLACK_STATUS_MAX_LENGTH = 50;
 function truncateWithEllipsis(text, maxLength) {
@@ -7234,112 +7390,11 @@ function logAssistantStatusFailure(status, error) {
   );
 }
-// src/chat/sandbox/sandbox.ts
-var SANDBOX_TOOL_NAMES = /* @__PURE__ */ new Set(["bash", "readFile", "writeFile"]);
-var DEFAULT_MAX_OUTPUT_LENGTH = 3e4;
-var SANDBOX_RUNTIME = "node22";
-var SANDBOX_RUNTIME_BIN_DIR = `${SANDBOX_WORKSPACE_ROOT}/.junior/bin`;
-var EVAL_GH_STUB_PATH = `${SANDBOX_RUNTIME_BIN_DIR}/gh`;
-var SNAPSHOT_BOOT_RETRY_COUNT = 3;
-var SNAPSHOT_BOOT_RETRY_DELAY_MS = 1e3;
-var SANDBOX_ERROR_FIELDS = [
-  {
-    sourceKey: "sandboxId",
-    attributeKey: "sandbox_id",
-    summaryKey: "sandboxId"
-  }
-];
-function mergeNetworkPolicyWithHeaderTransforms(networkPolicy, headerTransforms) {
-  const basePolicy = networkPolicy && typeof networkPolicy === "object" && !Array.isArray(networkPolicy) ? { ...networkPolicy } : {};
-  const existingAllowRaw = basePolicy.allow;
-  const existingAllow = existingAllowRaw && typeof existingAllowRaw === "object" && !Array.isArray(existingAllowRaw) ? Object.fromEntries(
-    Object.entries(existingAllowRaw).map(
-      ([domain, rules]) => [
-        domain,
-        Array.isArray(rules) ? [...rules] : []
-      ]
-    )
-  ) : { "*": [] };
-  for (const transform of headerTransforms) {
-    const currentRules = existingAllow[transform.domain] ?? [];
-    existingAllow[transform.domain] = [
-      ...currentRules,
-      { transform: [{ headers: transform.headers }] }
-    ];
-  }
-  return {
-    ...basePolicy,
-    allow: existingAllow
-  };
-}
-function truncateOutput(output, maxLength) {
-  if (output.length <= maxLength) {
-    return { value: output, truncated: false };
-  }
-  const truncatedLength = output.length - maxLength;
-  return {
-    value: `${output.slice(0, maxLength)}
+// src/chat/sandbox/skill-sync.ts
+import fs3 from "fs/promises";
+import path5 from "path";
-[output truncated: ${truncatedLength} characters removed]`,
-    truncated: true
-  };
-}
-function toPosixRelative(base, absolute) {
-  return path4.relative(base, absolute).split(path4.sep).join("/");
-}
-async function listFilesRecursive(root) {
-  const queue = [root];
-  const files = [];
-  while (queue.length > 0) {
-    const dir = queue.shift();
-    const entries = await fs3.readdir(dir, { withFileTypes: true });
-    entries.sort((a, b) => a.name.localeCompare(b.name));
-    for (const entry of entries) {
-      const absolute = path4.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        queue.push(absolute);
-      } else if (entry.isFile()) {
-        files.push(absolute);
-      }
-    }
-  }
-  return files;
-}
-async function buildSkillSyncFiles(availableSkills) {
-  const filesToWrite = [];
-  const index = {
-    skills: []
-  };
-  for (const skill of availableSkills) {
-    const skillFiles = await listFilesRecursive(skill.skillPath);
-    for (const absoluteFile of skillFiles) {
-      const relative = toPosixRelative(skill.skillPath, absoluteFile);
-      if (!relative || relative.startsWith("..")) {
-        continue;
-      }
-      filesToWrite.push({
-        path: `${sandboxSkillDir(skill.name)}/${relative}`,
-        content: await fs3.readFile(absoluteFile)
-      });
-    }
-    index.skills.push({
-      name: skill.name,
-      description: skill.description,
-      root: sandboxSkillDir(skill.name)
-    });
-  }
-  filesToWrite.push({
-    path: `${SANDBOX_SKILLS_ROOT}/index.json`,
-    content: Buffer.from(JSON.stringify(index), "utf8")
-  });
-  if (process.env.EVAL_ENABLE_TEST_CREDENTIALS === "1") {
-    filesToWrite.push({
-      path: EVAL_GH_STUB_PATH,
-      content: Buffer.from(buildEvalGitHubCliStub(), "utf8")
-    });
-  }
-  return filesToWrite;
-}
+// src/chat/sandbox/eval-gh-stub.ts
 function buildEvalGitHubCliStub() {
   return `#!/usr/bin/env node
 const fs = require("node:fs");
@@ -7517,6 +7572,8 @@ if (args[0] === "api") {
     outputJson({ items: [] });
     process.exit(0);
   }
+  outputJson({});
+  process.exit(0);
 }
 if (args[0] === "issue") {
@@ -7558,7 +7615,9 @@ if (args[0] === "issue") {
   const number = Number.parseInt(positionals[2] || "", 10);
   const key = repo + "#" + number;
-  const record = state.issues[key] || defaultIssue(repo, Number.isFinite(number) ? number : 101);
+  const record =
+    state.issues[key] ||
+    defaultIssue(repo, Number.isFinite(number) ? number : 101);
   if (subcommand === "view") {
     const jsonFields = getFlag("--json");
@@ -7599,134 +7658,379 @@ if (args[0] === "issue") {
 fallbackToRealGh();
 `;
 }
-function collectDirectories(filesToWrite) {
-  const directoriesToEnsure = /* @__PURE__ */ new Set();
-  for (const file of filesToWrite) {
-    const normalizedPath = path4.posix.normalize(file.path);
-    const parts = normalizedPath.split("/").filter(Boolean);
-    let current = "";
-    for (let index = 0; index < parts.length - 1; index += 1) {
-      current = `${current}/${parts[index]}`;
-      directoriesToEnsure.add(current);
+// src/chat/sandbox/skill-sync.ts
+function toPosixRelative(base, absolute) {
+  return path5.relative(base, absolute).split(path5.sep).join("/");
+}
+async function listFilesRecursive(root) {
+  const queue = [root];
+  const files = [];
+  while (queue.length > 0) {
+    const dir = queue.shift();
+    const entries = await fs3.readdir(dir, { withFileTypes: true });
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      const absolute = path5.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        queue.push(absolute);
+      } else if (entry.isFile()) {
+        files.push(absolute);
+      }
     }
   }
-  return Array.from(directoriesToEnsure).filter(
-    (directory) => directory === SANDBOX_WORKSPACE_ROOT || directory.startsWith(`${SANDBOX_WORKSPACE_ROOT}/`)
-  ).sort((a, b) => a.length - b.length);
-}
-function getSandboxErrorDetails(error) {
-  return extractHttpErrorDetails(error, {
-    attributePrefix: "app.sandbox.api_error",
-    extraFields: [...SANDBOX_ERROR_FIELDS]
-  });
+  return files;
 }
-function sleep2(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
+async function buildSkillSyncFiles(availableSkills, runtimeBinDir, referenceFiles) {
+  const filesToWrite = [];
+  const index = {
+    skills: []
+  };
+  for (const skill of availableSkills) {
+    const skillFiles = await listFilesRecursive(skill.skillPath);
+    for (const absoluteFile of skillFiles) {
+      const relative = toPosixRelative(skill.skillPath, absoluteFile);
+      if (!relative || relative.startsWith("..")) {
+        continue;
+      }
+      filesToWrite.push({
+        path: `${sandboxSkillDir(skill.name)}/${relative}`,
+        content: await fs3.readFile(absoluteFile)
+      });
+    }
+    index.skills.push({
+      name: skill.name,
+      description: skill.description,
+      root: sandboxSkillDir(skill.name)
+    });
+  }
+  filesToWrite.push({
+    path: `${SANDBOX_SKILLS_ROOT}/index.json`,
+    content: Buffer.from(JSON.stringify(index), "utf8")
   });
+  if (referenceFiles && referenceFiles.length > 0) {
+    for (const absoluteFile of referenceFiles) {
+      const fileName = path5.basename(absoluteFile);
+      filesToWrite.push({
+        path: `${SANDBOX_DATA_ROOT}/${fileName}`,
+        content: await fs3.readFile(absoluteFile)
+      });
+    }
+  }
+  if (process.env.EVAL_ENABLE_TEST_CREDENTIALS === "1") {
+    filesToWrite.push({
+      path: `${runtimeBinDir}/gh`,
+      content: Buffer.from(buildEvalGitHubCliStub(), "utf8")
+    });
+  }
+  return filesToWrite;
 }
-function isAlreadyExistsError(error) {
-  const details = getSandboxErrorDetails(error);
-  return details.searchableText.includes("already exists") || details.searchableText.includes("file exists") || details.searchableText.includes("eexist");
+function collectDirectories(filesToWrite, workspaceRoot) {
+  const directoriesToEnsure = /* @__PURE__ */ new Set();
+  for (const file of filesToWrite) {
+    const normalizedPath = path5.posix.normalize(file.path);
+    const parts = normalizedPath.split("/").filter(Boolean);
+    let current = "";
+    for (let index = 0; index < parts.length - 1; index += 1) {
+      current = `${current}/${parts[index]}`;
+      directoriesToEnsure.add(current);
+    }
+  }
+  return Array.from(directoriesToEnsure).filter(
+    (directory) => directory === workspaceRoot || directory.startsWith(`${workspaceRoot}/`)
+  ).sort((a, b) => a.length - b.length);
 }
-function findInErrorChain(error, predicate) {
-  const seen = /* @__PURE__ */ new Set();
-  let current = error;
-  while (current && !seen.has(current)) {
-    if (predicate(current)) {
-      return true;
+function resolveHostSkillPath(availableSkills, sandboxPath) {
+  const normalizedPath = path5.posix.normalize(sandboxPath.trim());
+  for (const skill of availableSkills) {
+    const virtualRoot = sandboxSkillDir(skill.name);
+    if (normalizedPath !== virtualRoot && !normalizedPath.startsWith(`${virtualRoot}/`)) {
+      continue;
     }
-    seen.add(current);
-    if (typeof current === "object") {
-      current = current.cause;
-    } else {
-      current = void 0;
+    const relativePath = path5.posix.relative(virtualRoot, normalizedPath);
+    if (!relativePath || relativePath.startsWith("../")) {
+      return null;
     }
+    const hostRoot = path5.resolve(skill.skillPath);
+    const hostPath = path5.resolve(hostRoot, ...relativePath.split("/"));
+    if (hostPath !== hostRoot && !hostPath.startsWith(`${hostRoot}${path5.sep}`)) {
+      return null;
+    }
+    return hostPath;
   }
-  return false;
-}
-function isSandboxUnavailableError(error) {
-  return findInErrorChain(error, (candidate) => {
-    const details = getSandboxErrorDetails(candidate);
-    const searchable = `${details.searchableText} ${details.summary}`.toLowerCase();
-    return searchable.includes("sandbox_stopped") || searchable.includes("status=410") || searchable.includes("status code 410") || searchable.includes("no longer available");
-  });
-}
-function isSnapshottingError(error) {
-  return findInErrorChain(error, (candidate) => {
-    const details = getSandboxErrorDetails(candidate);
-    const searchable = `${details.searchableText} ${details.summary}`.toLowerCase();
-    return searchable.includes("sandbox_snapshotting") || searchable.includes("creating a snapshot") || searchable.includes("stopped shortly");
-  });
+  return null;
 }
-function getFirstErrorMessage(error) {
-  const seen = /* @__PURE__ */ new Set();
-  let current = error;
-  while (current && !seen.has(current)) {
-    if (current instanceof Error) {
-      const message = current.message.trim();
-      if (message) {
-        return message;
-      }
+function resolveHostDataPath(referenceFiles, sandboxPath) {
+  const normalizedPath = path5.posix.normalize(sandboxPath.trim());
+  if (normalizedPath !== SANDBOX_DATA_ROOT && !normalizedPath.startsWith(`${SANDBOX_DATA_ROOT}/`)) {
+    return null;
+  }
+  const relativePath = path5.posix.relative(SANDBOX_DATA_ROOT, normalizedPath);
+  if (!relativePath || relativePath.startsWith("../") || relativePath.includes("/")) {
+    return null;
+  }
+  for (const hostFile of referenceFiles) {
+    if (path5.basename(hostFile) === relativePath) {
+      return hostFile;
     }
-    seen.add(current);
-    current = typeof current === "object" ? current.cause : void 0;
   }
-  return void 0;
+  return null;
 }
-function wrapSandboxSetupError(error) {
-  try {
-    const details = getSandboxErrorDetails(error);
-    if (details.summary) {
-      return new Error(`sandbox setup failed (${details.summary})`, {
-        cause: error
-      });
+function isHostFileMissingError(error) {
+  return Boolean(
+    error && typeof error === "object" && error.code === "ENOENT"
+  );
+}
+async function syncSkillsToSandbox(params) {
+  const workspaceRoot = params.workspaceRoot ?? SANDBOX_WORKSPACE_ROOT;
+  await params.withSpan(
+    "sandbox.sync_skills",
+    "sandbox.sync",
+    {
+      "app.sandbox.skills_count": params.skills.length
+    },
+    async () => {
+      const filesToWrite = await buildSkillSyncFiles(
+        params.skills,
+        params.runtimeBinDir,
+        params.referenceFiles
+      );
+      const bytesWritten = filesToWrite.reduce(
+        (total, file) => total + file.content.length,
+        0
+      );
+      const directories = collectDirectories(filesToWrite, workspaceRoot);
+      await params.withSpan(
+        "sandbox.sync_writeFiles",
+        "sandbox.sync.write",
+        {
+          "app.sandbox.sync.files_written": filesToWrite.length,
+          "app.sandbox.sync.bytes_written": bytesWritten,
+          "app.sandbox.sync.directories_ensured": directories.length
+        },
+        async () => {
+          try {
+            for (const directory of directories) {
+              try {
+                await params.sandbox.mkDir(directory);
+              } catch (error) {
+                if (!isAlreadyExistsError(error)) {
+                  throw error;
+                }
+              }
+            }
+            await params.sandbox.writeFiles(filesToWrite);
+            const executableFiles = filesToWrite.map((file) => file.path).filter(
+              (filePath) => filePath.startsWith(`${params.runtimeBinDir}/`)
+            );
+            for (const filePath of executableFiles) {
+              const chmod = await runNonInteractiveCommand(params.sandbox, {
+                cmd: "chmod",
+                args: ["0755", filePath],
+                cwd: workspaceRoot
+              });
+              if (chmod.exitCode !== 0) {
+                throw new Error(
+                  `sandbox chmod failed for ${filePath}: ${await chmod.stderr() || await chmod.stdout() || `exit ${chmod.exitCode}`}`
+                );
+              }
+            }
+          } catch (error) {
+            throwSandboxOperationError("sandbox writeFiles", error, true);
+          }
+        }
+      );
     }
-  } catch {
-  }
-  let causeMessage;
-  try {
-    causeMessage = getFirstErrorMessage(error);
-  } catch (cause) {
-    causeMessage = cause instanceof Error ? cause.message : void 0;
+  );
+}
+// src/chat/sandbox/session.ts
+var DEFAULT_MAX_OUTPUT_LENGTH = 3e4;
+var SANDBOX_RUNTIME = "node22";
+var SANDBOX_RUNTIME_BIN_DIR = `${SANDBOX_WORKSPACE_ROOT}/.junior/bin`;
+var SNAPSHOT_BOOT_RETRY_COUNT = 3;
+var SNAPSHOT_BOOT_RETRY_DELAY_MS = 1e3;
+var SNAPSHOT_PHASE_STATUS = {
+  resolve_start: { kind: "loading", context: "sandbox snapshot cache" },
+  waiting_for_lock: { kind: "loading", context: "sandbox snapshot build" },
+  building_snapshot: { kind: "creating", context: "sandbox snapshot" },
+  cache_hit: { kind: "loading", context: "sandbox snapshot" }
+};
+function mergeNetworkPolicyWithHeaderTransforms(networkPolicy, headerTransforms) {
+  const basePolicy = networkPolicy && typeof networkPolicy === "object" && !Array.isArray(networkPolicy) ? { ...networkPolicy } : {};
+  const existingAllowRaw = basePolicy.allow;
+  const existingAllow = existingAllowRaw && typeof existingAllowRaw === "object" && !Array.isArray(existingAllowRaw) ? Object.fromEntries(
+    Object.entries(existingAllowRaw).map(
+      ([domain, rules]) => [
+        domain,
+        Array.isArray(rules) ? [...rules] : []
+      ]
+    )
+  ) : { "*": [] };
+  for (const transform of headerTransforms) {
+    const currentRules = existingAllow[transform.domain] ?? [];
+    existingAllow[transform.domain] = [
+      ...currentRules,
+      { transform: [{ headers: transform.headers }] }
+    ];
   }
-  if (causeMessage && causeMessage.trim() && causeMessage !== "sandbox setup failed") {
-    const oneLine = causeMessage.replace(/\s+/g, " ").trim();
-    return new Error(`sandbox setup failed (${oneLine})`, { cause: error });
+  return {
+    ...basePolicy,
+    allow: existingAllow
+  };
+}
+function truncateOutput(output, maxLength) {
+  if (output.length <= maxLength) {
+    return { value: output, truncated: false };
   }
-  return new Error("sandbox setup failed", { cause: error });
+  const truncatedLength = output.length - maxLength;
+  return {
+    value: `${output.slice(0, maxLength)}
+[output truncated: ${truncatedLength} characters removed]`,
+    truncated: true
+  };
 }
-function throwSandboxOperationError(action, error, includeMissingPath = false) {
-  const details = getSandboxErrorDetails(error);
-  setSpanAttributes({
-    ...details.attributes,
-    ...includeMissingPath ? {
-      "app.sandbox.api_error.missing_path": details.searchableText.includes("no such file") || details.searchableText.includes("enoent")
-    } : {},
-    "app.sandbox.success": false
+function sleep2(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
   });
-  setSpanStatus("error");
-  throw new Error(
-    details.summary ? `${action} failed (${details.summary})` : `${action} failed`,
-    {
-      cause: error
+}
+function createStatusEmitter(emitStatus) {
+  let statusCount = 0;
+  const sentStatuses = /* @__PURE__ */ new Set();
+  const emit = async (status) => {
+    const statusKey = `${status.kind}:${status.context ?? ""}`;
+    if (!emitStatus || statusCount >= 4 || sentStatuses.has(statusKey)) {
+      return;
     }
+    sentStatuses.add(statusKey);
+    statusCount += 1;
+    await emitStatus(status);
+  };
+  const reportSnapshotPhase = async (phase) => {
+    const status = SNAPSHOT_PHASE_STATUS[phase];
+    if (status) {
+      await emit(makeAssistantStatus(status.kind, status.context));
+    }
+  };
+  return { emit, reportSnapshotPhase };
+}
+function parseKeepAliveMs() {
+  const parsed = Number.parseInt(
+    process.env.VERCEL_SANDBOX_KEEPALIVE_MS ?? "0",
+    10
   );
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
 }
-function createSandboxExecutor(options) {
+function createSandboxSessionManager(options) {
   let sandbox = null;
   let sandboxIdHint = options?.sandboxId;
   let availableSkills = [];
+  let availableReferenceFiles = [];
   let toolExecutors;
   const timeoutMs = options?.timeoutMs ?? 1e3 * 60 * 30;
   const traceContext = options?.traceContext ?? {};
-  const emitStatus = options?.onStatus;
   const dependencyProfileHash = getRuntimeDependencyProfileHash(SANDBOX_RUNTIME);
   const withSandboxSpan = (name, op, attributes, callback) => withSpan(name, op, traceContext, callback, attributes);
-  const createSandboxFromSnapshot = async (snapshotId, sandboxCredentials, onStatus) => {
+  const emitSandboxStatus = async (source, statusEmitter, status) => {
+    logInfo(
+      "sandbox_status_emitted",
+      traceContext,
+      {
+        "app.sandbox.status.source": source,
+        "app.sandbox.status.kind": status.kind,
+        ...status.context ? { "app.sandbox.status.context": status.context } : {}
+      },
+      "Sandbox status emitted"
+    );
+    if (typeof statusEmitter === "function") {
+      await statusEmitter(status);
+      return;
+    }
+    await statusEmitter.emit(status);
+  };
+  const clearSession = () => {
+    sandbox = null;
+    sandboxIdHint = void 0;
+    toolExecutors = void 0;
+  };
+  const rememberSandbox = (nextSandbox) => {
+    sandbox = nextSandbox;
+    sandboxIdHint = nextSandbox.sandboxId;
+    toolExecutors = void 0;
+    return nextSandbox;
+  };
+  const failSetup = (error) => {
+    throw wrapSandboxSetupError(error);
+  };
+  const syncSkills = async (targetSandbox) => {
+    await syncSkillsToSandbox({
+      sandbox: targetSandbox,
+      skills: availableSkills,
+      referenceFiles: availableReferenceFiles,
+      withSpan: withSandboxSpan,
+      runtimeBinDir: SANDBOX_RUNTIME_BIN_DIR
+    });
+  };
+  const ensureSandboxReachable = async (targetSandbox, source) => {
+    await withSandboxSpan(
+      "sandbox.reuse_probe",
+      "sandbox.acquire.probe",
+      {
+        "app.sandbox.reused": true,
+        "app.sandbox.source": source
+      },
+      async () => {
+        try {
+          await targetSandbox.mkDir(SANDBOX_WORKSPACE_ROOT);
+        } catch (error) {
+          if (!isAlreadyExistsError(error)) {
+            throw error;
+          }
+        }
+      }
+    );
+  };
+  const invalidateSandboxInstance = async (targetSandbox, reason) => {
+    if (sandbox === targetSandbox) {
+      clearSession();
+    }
+    logWarn(
+      "sandbox_network_policy_restore_failed",
+      traceContext,
+      {
+        "error.message": reason instanceof Error ? reason.message : String(reason)
+      },
+      "Sandbox network policy restore failed; discarding sandbox instance"
+    );
+    try {
+      await targetSandbox.stop({ blocking: true });
+    } catch {
+    }
+  };
+  const recreateUnavailableSandbox = async (source) => {
+    setSpanAttributes({
+      "app.sandbox.recovery.attempted": true,
+      "app.sandbox.recovery.source": source
+    });
+    clearSession();
+    const replacement = await createFreshSandbox();
+    setSpanAttributes({
+      "app.sandbox.recovery.succeeded": true
+    });
+    return replacement;
+  };
+  const createSandboxFromSnapshot = async (snapshotId, sandboxCredentials, emitStatus) => {
     for (let attempt = 0; attempt < SNAPSHOT_BOOT_RETRY_COUNT; attempt += 1) {
       try {
-        await onStatus?.(makeAssistantStatus("loading", "sandbox"));
+        if (emitStatus) {
+          await emitSandboxStatus(
+            "snapshot_boot",
+            emitStatus,
+            makeAssistantStatus("loading", "sandbox")
+          );
+        }
         return await Sandbox.create({
           timeout: timeoutMs,
           source: {
@@ -7744,309 +8048,265 @@ function createSandboxExecutor(options) {
     }
     throw new Error(`Failed to boot sandbox from snapshot ${snapshotId}`);
   };
-  const invalidateSandboxInstance = async (targetSandbox, reason) => {
-    if (sandbox === targetSandbox) {
-      sandbox = null;
-      sandboxIdHint = void 0;
-      toolExecutors = void 0;
+  const setSnapshotAttributes = (snapshot) => {
+    setSpanAttributes({
+      "app.sandbox.source": snapshot.snapshotId ? "snapshot" : "created",
+      "app.sandbox.snapshot.cache_hit": snapshot.cacheHit,
+      "app.sandbox.snapshot.resolve_outcome": snapshot.resolveOutcome,
+      ...snapshot.profileHash ? {
+        "app.sandbox.snapshot.profile_hash": snapshot.profileHash
+      } : {},
+      "app.sandbox.snapshot.dependency_count": snapshot.dependencyCount,
+      ...snapshot.rebuildReason ? {
+        "app.sandbox.snapshot.rebuild_reason": snapshot.rebuildReason
+      } : {}
+    });
+  };
+  const createSandboxFromResolvedSnapshot = async (params) => {
+    const { runtime, snapshot, sandboxCredentials, status } = params;
+    if (!snapshot.snapshotId) {
+      await emitSandboxStatus(
+        "fresh_runtime_boot",
+        status,
+        makeAssistantStatus("loading", "sandbox")
+      );
+      return await Sandbox.create({
+        timeout: timeoutMs,
+        runtime,
+        ...sandboxCredentials ?? {}
+      });
     }
-    logWarn(
-      "sandbox_network_policy_restore_failed",
-      traceContext,
-      {
-        "error.message": reason instanceof Error ? reason.message : String(reason)
-      },
-      "Sandbox network policy restore failed; discarding sandbox instance"
-    );
     try {
-      await targetSandbox.stop({ blocking: true });
-    } catch {
-    }
-  };
-  const upsertSkillsToSandbox = async (targetSandbox) => {
-    await withSandboxSpan(
-      "sandbox.sync_skills",
-      "sandbox.sync",
-      {
-        "app.sandbox.skills_count": availableSkills.length
-      },
-      async () => {
-        const filesToWrite = await buildSkillSyncFiles(availableSkills);
-        const bytesWritten = filesToWrite.reduce(
-          (total, file) => total + file.content.length,
-          0
-        );
-        const directories = collectDirectories(filesToWrite);
-        await withSandboxSpan(
-          "sandbox.sync_writeFiles",
-          "sandbox.sync.write",
-          {
-            "app.sandbox.sync.files_written": filesToWrite.length,
-            "app.sandbox.sync.bytes_written": bytesWritten,
-            "app.sandbox.sync.directories_ensured": directories.length
-          },
-          async () => {
-            try {
-              for (const directory of directories) {
-                try {
-                  await targetSandbox.mkDir(directory);
-                } catch (error) {
-                  if (!isAlreadyExistsError(error)) {
-                    throw error;
-                  }
-                }
-              }
-              await targetSandbox.writeFiles(filesToWrite);
-              const executableFiles = filesToWrite.map((file) => file.path).filter(
-                (filePath) => filePath.startsWith(`${SANDBOX_RUNTIME_BIN_DIR}/`)
-              );
-              for (const filePath of executableFiles) {
-                const chmod = await runNonInteractiveCommand(targetSandbox, {
-                  cmd: "chmod",
-                  args: ["0755", filePath],
-                  cwd: SANDBOX_WORKSPACE_ROOT
-                });
-                if (chmod.exitCode !== 0) {
-                  throw new Error(
-                    `sandbox chmod failed for ${filePath}: ${await chmod.stderr() || await chmod.stdout() || `exit ${chmod.exitCode}`}`
-                  );
-                }
-              }
-            } catch (error) {
-              throwSandboxOperationError("sandbox writeFiles", error, true);
-            }
-          }
-        );
+      return await createSandboxFromSnapshot(
+        snapshot.snapshotId,
+        sandboxCredentials,
+        status.emit
+      );
+    } catch (error) {
+      if (!isSnapshotMissingError(error)) {
+        throw error;
       }
-    );
+      setSpanAttributes({
+        "app.sandbox.snapshot.rebuild_after_missing": true
+      });
+      const rebuiltSnapshot = await resolveRuntimeDependencySnapshot({
+        runtime,
+        timeoutMs,
+        forceRebuild: true,
+        staleSnapshotId: snapshot.snapshotId,
+        onProgress: status.reportSnapshotPhase
+      });
+      if (!rebuiltSnapshot.snapshotId) {
+        throw error;
+      }
+      return await createSandboxFromSnapshot(
+        rebuiltSnapshot.snapshotId,
+        sandboxCredentials,
+        status.emit
+      );
+    }
   };
-  const acquireSandbox = async () => {
-    return withSandboxSpan(
-      "sandbox.acquire",
-      "sandbox.acquire",
-      {
-        "app.sandbox.id_hint_present": Boolean(sandboxIdHint),
-        "app.sandbox.timeout_ms": timeoutMs,
-        "app.sandbox.runtime": "node22",
-        "app.sandbox.skills_count": availableSkills.length
-      },
-      async () => {
-        const sandboxCredentials = getVercelSandboxCredentials();
-        const assignSandbox = (nextSandbox) => {
-          sandbox = nextSandbox;
-          sandboxIdHint = nextSandbox.sandboxId;
-          toolExecutors = void 0;
-          return nextSandbox;
-        };
-        const handleSetupFailure = (error) => {
-          throw wrapSandboxSetupError(error);
-        };
-        const createFreshSandbox = async () => {
-          const runtime = SANDBOX_RUNTIME;
-          let statusCount = 0;
-          const sentStatuses = /* @__PURE__ */ new Set();
-          const emitSandboxStatus = async (status) => {
-            const statusKey = `${status.kind}:${status.context ?? ""}`;
-            if (!emitStatus || statusCount >= 4 || sentStatuses.has(statusKey)) {
-              return;
-            }
-            sentStatuses.add(statusKey);
-            statusCount += 1;
-            await emitStatus(status);
-          };
-          const reportSnapshotPhase = async (phase) => {
-            if (phase === "resolve_start") {
-              await emitSandboxStatus(
-                makeAssistantStatus("loading", "sandbox snapshot cache")
-              );
-              return;
-            }
-            if (phase === "waiting_for_lock") {
-              await emitSandboxStatus(
-                makeAssistantStatus("loading", "sandbox snapshot build")
-              );
-              return;
-            }
-            if (phase === "building_snapshot") {
-              await emitSandboxStatus(
-                makeAssistantStatus("creating", "sandbox snapshot")
-              );
-              return;
-            }
-            if (phase === "cache_hit") {
-              await emitSandboxStatus(
-                makeAssistantStatus("loading", "sandbox snapshot")
-              );
-            }
-          };
-          let createdSandbox;
-          try {
-            createdSandbox = await withSandboxSpan(
-              "sandbox.create",
-              "sandbox.create",
-              {
-                "app.sandbox.reused": false,
-                "app.sandbox.timeout_ms": timeoutMs,
-                "app.sandbox.runtime": runtime
-              },
-              async () => {
-                await emitSandboxStatus(
-                  makeAssistantStatus("loading", "sandbox runtime")
-                );
-                const snapshot = await resolveRuntimeDependencySnapshot({
-                  runtime,
-                  timeoutMs,
-                  onProgress: reportSnapshotPhase
-                });
-                setSpanAttributes({
-                  "app.sandbox.source": snapshot.snapshotId ? "snapshot" : "created",
-                  "app.sandbox.snapshot.cache_hit": snapshot.cacheHit,
-                  "app.sandbox.snapshot.resolve_outcome": snapshot.resolveOutcome,
-                  ...snapshot.profileHash ? {
-                    "app.sandbox.snapshot.profile_hash": snapshot.profileHash
-                  } : {},
-                  "app.sandbox.snapshot.dependency_count": snapshot.dependencyCount,
-                  ...snapshot.rebuildReason ? {
-                    "app.sandbox.snapshot.rebuild_reason": snapshot.rebuildReason
-                  } : {}
-                });
-                if (!snapshot.snapshotId) {
-                  await emitSandboxStatus(
-                    makeAssistantStatus("loading", "sandbox")
-                  );
-                  return await Sandbox.create({
-                    timeout: timeoutMs,
-                    runtime,
-                    ...sandboxCredentials ?? {}
-                  });
-                }
-                try {
-                  return await createSandboxFromSnapshot(
-                    snapshot.snapshotId,
-                    sandboxCredentials,
-                    emitSandboxStatus
-                  );
-                } catch (error) {
-                  if (!isSnapshotMissingError(error)) {
-                    throw error;
-                  }
-                  setSpanAttributes({
-                    "app.sandbox.snapshot.rebuild_after_missing": true
-                  });
-                  const rebuiltSnapshot = await resolveRuntimeDependencySnapshot({
-                    runtime,
-                    timeoutMs,
-                    forceRebuild: true,
-                    staleSnapshotId: snapshot.snapshotId,
-                    onProgress: reportSnapshotPhase
-                  });
-                  if (!rebuiltSnapshot.snapshotId) {
-                    throw error;
-                  }
-                  return await createSandboxFromSnapshot(
-                    rebuiltSnapshot.snapshotId,
-                    sandboxCredentials,
-                    emitSandboxStatus
-                  );
-                }
-              }
-            );
-          } catch (error) {
-            return handleSetupFailure(error);
-          }
-          try {
-            await upsertSkillsToSandbox(createdSandbox);
-          } catch (error) {
-            return handleSetupFailure(error);
-          }
-          return assignSandbox(createdSandbox);
-        };
-        if (!sandbox && sandboxIdHint && dependencyProfileHash !== options?.sandboxDependencyProfileHash) {
-          setSpanAttributes({
-            "app.sandbox.reused": false,
-            "app.sandbox.recreate.reason": "dependency_profile_mismatch",
-            ...options?.sandboxDependencyProfileHash ? {
-              "app.sandbox.previous_profile_hash": options.sandboxDependencyProfileHash
-            } : {},
-            ...dependencyProfileHash ? { "app.sandbox.current_profile_hash": dependencyProfileHash } : {}
-          });
-          sandboxIdHint = void 0;
-        }
-        const recoverUnavailableSandbox = async (source) => {
-          setSpanAttributes({
-            "app.sandbox.recovery.attempted": true,
-            "app.sandbox.recovery.source": source
-          });
-          sandbox = null;
-          sandboxIdHint = void 0;
-          toolExecutors = void 0;
-          const replacement = await createFreshSandbox();
-          setSpanAttributes({
-            "app.sandbox.recovery.succeeded": true
-          });
-          return replacement;
-        };
-        if (sandbox) {
-          const cachedSandbox = sandbox;
-          try {
-            await withSandboxSpan(
-              "sandbox.reuse_cached",
-              "sandbox.acquire.cached",
-              {
-                "app.sandbox.reused": true,
-                "app.sandbox.source": "memory"
-              },
-              async () => {
-                await upsertSkillsToSandbox(cachedSandbox);
-              }
-            );
-            return cachedSandbox;
-          } catch (error) {
-            if (isSandboxUnavailableError(error)) {
-              return recoverUnavailableSandbox("memory");
-            }
-            return handleSetupFailure(error);
-          }
+  const createFreshSandbox = async () => {
+    const runtime = SANDBOX_RUNTIME;
+    const sandboxCredentials = getVercelSandboxCredentials();
+    const status = createStatusEmitter(options?.onStatus);
+    let createdSandbox;
+    try {
+      createdSandbox = await withSandboxSpan(
+        "sandbox.create",
+        "sandbox.create",
+        {
+          "app.sandbox.reused": false,
+          "app.sandbox.timeout_ms": timeoutMs,
+          "app.sandbox.runtime": runtime
+        },
+        async () => {
+          await emitSandboxStatus(
+            "runtime_dependency_resolve",
+            status,
+            makeAssistantStatus("loading", "sandbox runtime")
+          );
+          const snapshot = await resolveRuntimeDependencySnapshot({
+            runtime,
+            timeoutMs,
+            onProgress: status.reportSnapshotPhase
+          });
+          setSnapshotAttributes(snapshot);
+          return await createSandboxFromResolvedSnapshot({
+            runtime,
+            snapshot,
+            sandboxCredentials,
+            status
+          });
         }
-        let acquiredSandbox = null;
-        if (sandboxIdHint) {
-          try {
-            acquiredSandbox = await withSandboxSpan(
-              "sandbox.get",
-              "sandbox.get",
-              {
-                "app.sandbox.reused": true,
-                "app.sandbox.source": "id_hint"
-              },
-              async () => Sandbox.get({
-                sandboxId: sandboxIdHint,
-                ...sandboxCredentials ?? {}
-              })
-            );
-          } catch {
-            acquiredSandbox = null;
-          }
+      );
+    } catch (error) {
+      return failSetup(error);
+    }
+    try {
+      await syncSkills(createdSandbox);
+    } catch (error) {
+      return failSetup(error);
+    }
+    return rememberSandbox(createdSandbox);
+  };
+  const discardHintIfProfileChanged = () => {
+    if (sandbox || !sandboxIdHint || dependencyProfileHash === options?.sandboxDependencyProfileHash) {
+      return;
+    }
+    setSpanAttributes({
+      "app.sandbox.reused": false,
+      "app.sandbox.recreate.reason": "dependency_profile_mismatch",
+      ...options?.sandboxDependencyProfileHash ? {
+        "app.sandbox.previous_profile_hash": options.sandboxDependencyProfileHash
+      } : {},
+      ...dependencyProfileHash ? { "app.sandbox.current_profile_hash": dependencyProfileHash } : {}
+    });
+    sandboxIdHint = void 0;
+  };
+  const tryReuseCachedSandbox = async () => {
+    const cachedSandbox = sandbox;
+    if (!cachedSandbox) {
+      return null;
+    }
+    try {
+      await ensureSandboxReachable(cachedSandbox, "memory");
+      return cachedSandbox;
+    } catch (error) {
+      if (isSandboxUnavailableError(error)) {
+        return await recreateUnavailableSandbox("memory");
+      }
+      return failSetup(error);
+    }
+  };
+  const tryRestoreHintedSandbox = async () => {
+    if (!sandboxIdHint) {
+      return null;
+    }
+    let hintedSandbox = null;
+    try {
+      const sandboxCredentials = getVercelSandboxCredentials();
+      hintedSandbox = await withSandboxSpan(
+        "sandbox.get",
+        "sandbox.get",
+        {
+          "app.sandbox.reused": true,
+          "app.sandbox.source": "id_hint"
+        },
+        async () => await Sandbox.get({
+          sandboxId: sandboxIdHint,
+          ...sandboxCredentials ?? {}
+        })
+      );
+    } catch {
+      return null;
+    }
+    try {
+      await syncSkills(hintedSandbox);
+      return rememberSandbox(hintedSandbox);
+    } catch (error) {
+      if (isSandboxUnavailableError(error)) {
+        return await recreateUnavailableSandbox("id_hint");
+      }
+      return failSetup(error);
+    }
+  };
+  const acquireSandbox = async () => {
+    return await withSandboxSpan(
+      "sandbox.acquire",
+      "sandbox.acquire",
+      {
+        "app.sandbox.id_hint_present": Boolean(sandboxIdHint),
+        "app.sandbox.timeout_ms": timeoutMs,
+        "app.sandbox.runtime": SANDBOX_RUNTIME,
+        "app.sandbox.skills_count": availableSkills.length
+      },
+      async () => {
+        discardHintIfProfileChanged();
+        const cachedSandbox = await tryReuseCachedSandbox();
+        if (cachedSandbox) {
+          return cachedSandbox;
         }
-        if (acquiredSandbox) {
-          try {
-            await upsertSkillsToSandbox(acquiredSandbox);
-            return assignSandbox(acquiredSandbox);
-          } catch (error) {
-            if (isSandboxUnavailableError(error)) {
-              return recoverUnavailableSandbox("id_hint");
-            }
-            return handleSetupFailure(error);
-          }
+        const hintedSandbox = await tryRestoreHintedSandbox();
+        if (hintedSandbox) {
+          return hintedSandbox;
         }
-        return createFreshSandbox();
+        return await createFreshSandbox();
       }
     );
   };
-  const getToolExecutors = async () => {
-    if (toolExecutors) {
-      return toolExecutors;
+  const getMaxOutputLength = () => {
+    const maxOutputLength = Number.parseInt(
+      process.env.SANDBOX_BASH_MAX_OUTPUT_CHARS ?? "",
+      10
+    );
+    return Number.isFinite(maxOutputLength) && maxOutputLength > 0 ? maxOutputLength : DEFAULT_MAX_OUTPUT_LENGTH;
+  };
+  const readCommandOutput = async (commandResult2) => {
+    const boundedOutputLength = getMaxOutputLength();
+    const stdoutRaw = await commandResult2.stdout();
+    const stderrRaw = await commandResult2.stderr();
+    const stdout = truncateOutput(stdoutRaw, boundedOutputLength);
+    const stderr = truncateOutput(stderrRaw, boundedOutputLength);
+    return {
+      stdout: stdout.value,
+      stderr: stderr.value,
+      exitCode: commandResult2.exitCode,
+      stdoutTruncated: stdout.truncated,
+      stderrTruncated: stderr.truncated
+    };
+  };
+  const withTemporaryHeaderTransforms = async (sandboxInstance, headerTransforms, callback) => {
+    if (!headerTransforms || headerTransforms.length === 0) {
+      return await callback();
+    }
+    const restoreNetworkPolicy = sandboxInstance.networkPolicy ?? "allow-all";
+    const policy = mergeNetworkPolicyWithHeaderTransforms(
+      restoreNetworkPolicy,
+      headerTransforms
+    );
+    await sandboxInstance.updateNetworkPolicy(policy);
+    let callbackError;
+    let restoreError;
+    let result;
+    try {
+      result = await callback();
+    } catch (error) {
+      callbackError = error;
+      throw error;
+    } finally {
+      try {
+        await sandboxInstance.updateNetworkPolicy(restoreNetworkPolicy);
+      } catch (error) {
+        restoreError = error;
+        await invalidateSandboxInstance(sandboxInstance, error);
+      }
     }
-    const activeSandbox = await acquireSandbox();
+    if (restoreError && !callbackError) {
+      throw restoreError;
+    }
+    return result;
+  };
+  const extendKeepAlive = async (activeSandbox) => {
+    const keepAliveMs = parseKeepAliveMs();
+    if (keepAliveMs === 0) {
+      return;
+    }
+    try {
+      await withSandboxSpan(
+        "sandbox.keepalive.extend",
+        "sandbox.keepalive",
+        {
+          "app.sandbox.keepalive_ms": keepAliveMs
+        },
+        async () => {
+          await activeSandbox.extendTimeout(keepAliveMs);
+        }
+      );
+    } catch {
+    }
+  };
+  const buildToolExecutors = async (sandboxInstance) => {
     const toolkit = await withSandboxSpan(
       "sandbox.bash_tool.init",
       "sandbox.tool.init",
@@ -8054,8 +8314,8 @@ function createSandboxExecutor(options) {
         "app.sandbox.tool_name": "bash",
         "app.sandbox.destination": SANDBOX_WORKSPACE_ROOT
       },
-      async () => createBashTool2({
-        sandbox: activeSandbox,
+      async () => await createBashTool2({
+        sandbox: sandboxInstance,
         destination: SANDBOX_WORKSPACE_ROOT
       })
     );
@@ -8064,63 +8324,24 @@ function createSandboxExecutor(options) {
     if (!executeReadFile || !executeWriteFile) {
       throw new Error("bash-tool did not return executable tool handlers");
     }
-    toolExecutors = {
+    return {
       bash: async (input) => {
-        const restoreNetworkPolicy = activeSandbox.networkPolicy ?? "allow-all";
-        const headerTransforms = input.headerTransforms;
-        if (headerTransforms && headerTransforms.length > 0) {
-          const policy = mergeNetworkPolicyWithHeaderTransforms(
-            restoreNetworkPolicy,
-            headerTransforms
-          );
-          await activeSandbox.updateNetworkPolicy(policy);
-        }
         const script = buildNonInteractiveShellScript(input.command, {
           env: input.env,
           pathPrefix: `${SANDBOX_RUNTIME_BIN_DIR}:$PATH`
         });
-        let commandError;
-        let result;
-        let restoreError;
-        try {
-          const commandResult2 = await activeSandbox.runCommand({
-            cmd: "bash",
-            args: ["-c", script],
-            cwd: SANDBOX_WORKSPACE_ROOT
-          });
-          const maxOutputLength = Number.parseInt(
-            process.env.SANDBOX_BASH_MAX_OUTPUT_CHARS ?? "",
-            10
-          );
-          const boundedOutputLength = Number.isFinite(maxOutputLength) && maxOutputLength > 0 ? maxOutputLength : DEFAULT_MAX_OUTPUT_LENGTH;
-          const stdoutRaw = await commandResult2.stdout();
-          const stderrRaw = await commandResult2.stderr();
-          const stdout = truncateOutput(stdoutRaw, boundedOutputLength);
-          const stderr = truncateOutput(stderrRaw, boundedOutputLength);
-          result = {
-            stdout: stdout.value,
-            stderr: stderr.value,
-            exitCode: commandResult2.exitCode,
-            stdoutTruncated: stdout.truncated,
-            stderrTruncated: stderr.truncated
-          };
-        } catch (error) {
-          commandError = error;
-          throw error;
-        } finally {
-          if (headerTransforms && headerTransforms.length > 0) {
-            try {
-              await activeSandbox.updateNetworkPolicy(restoreNetworkPolicy);
-            } catch (error) {
-              restoreError = error;
-              await invalidateSandboxInstance(activeSandbox, error);
-            }
+        return await withTemporaryHeaderTransforms(
+          sandboxInstance,
+          input.headerTransforms,
+          async () => {
+            const commandResult2 = await sandboxInstance.runCommand({
+              cmd: "bash",
+              args: ["-c", script],
+              cwd: SANDBOX_WORKSPACE_ROOT
+            });
+            return await readCommandOutput(commandResult2);
           }
-        }
-        if (restoreError && !commandError) {
-          throw restoreError;
-        }
-        return result;
+        );
       },
       readFile: async (input) => await executeReadFile(input, {
         toolCallId: "sandbox-read-file",
@@ -8131,210 +8352,319 @@ function createSandboxExecutor(options) {
         messages: []
       })
     };
-    return toolExecutors;
   };
-  const execute = async (params) => {
-    const rawInput = params.input ?? {};
-    const bashCommand = params.toolName === "bash" ? String(rawInput.command ?? "").trim() : void 0;
-    if (params.toolName === "bash") {
-      if (!bashCommand) {
-        throw new Error("command is required");
-      }
-      if (options?.runBashCustomCommand) {
-        const custom = await options.runBashCustomCommand(bashCommand);
-        if (custom.handled) {
-          return { result: custom.result };
-        }
-      }
-    }
+  const ensureReadySandbox = async () => {
     const activeSandbox = await acquireSandbox();
-    const keepAliveMs = Number.parseInt(
-      process.env.VERCEL_SANDBOX_KEEPALIVE_MS ?? "0",
-      10
-    );
-    if (Number.isFinite(keepAliveMs) && keepAliveMs > 0) {
-      try {
-        await withSandboxSpan(
-          "sandbox.keepalive.extend",
-          "sandbox.keepalive",
-          {
-            "app.sandbox.keepalive_ms": keepAliveMs
-          },
-          async () => {
-            await activeSandbox.extendTimeout(keepAliveMs);
-          }
-        );
-      } catch {
-      }
+    await extendKeepAlive(activeSandbox);
+    return activeSandbox;
+  };
+  const loadToolExecutors = async (activeSandbox) => {
+    if (toolExecutors) {
+      return toolExecutors;
     }
-    if (params.toolName === "bash") {
-      const command = bashCommand;
-      const headerTransformsInput = rawInput.headerTransforms;
-      const headerTransforms = Array.isArray(headerTransformsInput) ? headerTransformsInput.filter(
-        (value) => Boolean(value && typeof value === "object")
-      ).map((transform) => ({
-        domain: String(transform.domain ?? "").trim(),
-        headers: transform.headers && typeof transform.headers === "object" && !Array.isArray(transform.headers) ? Object.fromEntries(
-          Object.entries(
-            transform.headers
-          ).filter(([, value]) => typeof value === "string").map(([key, value]) => [key, value])
-        ) : {}
-      })).filter(
-        (transform) => transform.domain.length > 0 && Object.keys(transform.headers).length > 0
-      ) : void 0;
-      const envInput = rawInput.env;
-      const env = envInput && typeof envInput === "object" && !Array.isArray(envInput) ? Object.fromEntries(
-        Object.entries(envInput).filter(([, value]) => typeof value === "string").map(([key, value]) => [key, value])
-      ) : void 0;
-      const executeBash = (await getToolExecutors()).bash;
-      const result = await withSandboxSpan(
-        "bash",
-        "process.exec",
+    toolExecutors = await buildToolExecutors(activeSandbox);
+    return toolExecutors;
+  };
+  return {
+    configureSkills(skills) {
+      availableSkills = [...skills];
+    },
+    configureReferenceFiles(files) {
+      availableReferenceFiles = [...files];
+    },
+    getSandboxId() {
+      return sandbox?.sandboxId ?? sandboxIdHint;
+    },
+    getDependencyProfileHash() {
+      return dependencyProfileHash;
+    },
+    async createSandbox() {
+      return await acquireSandbox();
+    },
+    async ensureToolExecutors() {
+      return await loadToolExecutors(await ensureReadySandbox());
+    },
+    async dispose() {
+      const activeSandbox = sandbox;
+      if (!activeSandbox) {
+        return;
+      }
+      await withSandboxSpan(
+        "sandbox.stop",
+        "sandbox.stop",
         {
-          "process.executable.name": "bash"
+          "app.sandbox.stop.blocking": true
         },
         async () => {
-          try {
-            const response = await executeBash({
-              command,
-              ...headerTransforms ? { headerTransforms } : {},
-              ...env ? { env } : {}
-            });
-            setSpanAttributes({
-              "process.exit.code": response.exitCode,
-              "app.sandbox.stdout_bytes": Buffer.byteLength(
-                response.stdout ?? "",
-                "utf8"
-              ),
-              "app.sandbox.stderr_bytes": Buffer.byteLength(
-                response.stderr ?? "",
-                "utf8"
-              ),
-              ...response.exitCode !== 0 ? { "error.type": "nonzero_exit" } : {}
-            });
-            setSpanStatus(response.exitCode === 0 ? "ok" : "error");
-            return response;
-          } catch (error) {
-            setSpanAttributes({
-              "error.type": error instanceof Error ? error.name : "sandbox_execute_error"
-            });
-            setSpanStatus("error");
-            throw error;
-          }
+          await activeSandbox.stop({ blocking: true });
         }
       );
-      return {
-        result: {
-          ok: result.exitCode === 0,
-          command,
-          cwd: SANDBOX_WORKSPACE_ROOT,
-          exit_code: result.exitCode,
-          signal: null,
-          timed_out: false,
-          stdout: result.stdout,
-          stderr: result.stderr,
-          stdout_truncated: result.stdoutTruncated,
-          stderr_truncated: result.stderrTruncated
-        }
-      };
+      sandbox = null;
+      toolExecutors = void 0;
     }
-    if (params.toolName === "readFile") {
-      const filePath = String(rawInput.path ?? "").trim();
-      if (!filePath) {
-        throw new Error("path is required");
-      }
-      const executeReadFile = (await getToolExecutors()).readFile;
-      const result = await withSandboxSpan(
-        "sandbox.readFile",
-        "sandbox.fs.read",
-        {
-          "app.sandbox.path.length": filePath.length
-        },
-        async () => {
-          const response = await executeReadFile({ path: filePath });
-          const content = String(response.content ?? "");
+  };
+}
+// src/chat/sandbox/sandbox.ts
+var SANDBOX_TOOL_NAMES = /* @__PURE__ */ new Set(["bash", "readFile", "writeFile"]);
+function parseHeaderTransforms(raw) {
+  if (!Array.isArray(raw)) {
+    return void 0;
+  }
+  return raw.filter(
+    (value) => Boolean(value && typeof value === "object")
+  ).map((transform) => ({
+    domain: String(transform.domain ?? "").trim(),
+    headers: transform.headers && typeof transform.headers === "object" && !Array.isArray(transform.headers) ? Object.fromEntries(
+      Object.entries(transform.headers).filter(([, value]) => typeof value === "string").map(([key, value]) => [key, value])
+    ) : {}
+  })).filter(
+    (transform) => transform.domain.length > 0 && Object.keys(transform.headers).length > 0
+  );
+}
+function parseEnv(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return void 0;
+  }
+  return Object.fromEntries(
+    Object.entries(raw).filter(([, value]) => typeof value === "string").map(([key, value]) => [key, value])
+  );
+}
+function createSandboxWorkspace(sandbox) {
+  return {
+    sandboxId: sandbox.sandboxId,
+    readFileToBuffer(input) {
+      return sandbox.readFileToBuffer(input);
+    },
+    runCommand(input) {
+      return sandbox.runCommand(input);
+    }
+  };
+}
+function createSandboxExecutor(options) {
+  let availableSkills = [];
+  let referenceFiles = [];
+  const traceContext = options?.traceContext ?? {};
+  const sessionManager = createSandboxSessionManager({
+    sandboxId: options?.sandboxId,
+    sandboxDependencyProfileHash: options?.sandboxDependencyProfileHash,
+    timeoutMs: options?.timeoutMs,
+    traceContext,
+    onStatus: options?.onStatus
+  });
+  const withSandboxSpan = (name, op, attributes, callback) => withSpan(name, op, traceContext, callback, attributes);
+  const logSandboxBootRequest = (trigger, details = {}) => {
+    if (sessionManager.getSandboxId()) {
+      return;
+    }
+    logInfo(
+      "sandbox_boot_requested",
+      traceContext,
+      {
+        "app.sandbox.boot.trigger": trigger,
+        ...details
+      },
+      "Sandbox boot requested"
+    );
+  };
+  const executeBashTool = async (rawInput, command) => {
+    const headerTransforms = parseHeaderTransforms(rawInput.headerTransforms);
+    const env = parseEnv(rawInput.env);
+    logSandboxBootRequest("tool.bash", {
+      "app.sandbox.command_length": command.length
+    });
+    const executeBash = (await sessionManager.ensureToolExecutors()).bash;
+    const result = await withSandboxSpan(
+      "bash",
+      "process.exec",
+      {
+        "process.executable.name": "bash"
+      },
+      async () => {
+        try {
+          const response = await executeBash({
+            command,
+            ...headerTransforms ? { headerTransforms } : {},
+            ...env ? { env } : {}
+          });
+          setSpanAttributes({
+            "process.exit.code": response.exitCode,
+            "app.sandbox.stdout_bytes": Buffer.byteLength(
+              response.stdout ?? "",
+              "utf8"
+            ),
+            "app.sandbox.stderr_bytes": Buffer.byteLength(
+              response.stderr ?? "",
+              "utf8"
+            ),
+            ...response.exitCode !== 0 ? { "error.type": "nonzero_exit" } : {}
+          });
+          setSpanStatus(response.exitCode === 0 ? "ok" : "error");
+          return response;
+        } catch (error) {
+          setSpanAttributes({
+            "error.type": error instanceof Error ? error.name : "sandbox_execute_error"
+          });
+          setSpanStatus("error");
+          throw error;
+        }
+      }
+    );
+    return {
+      result: {
+        ok: result.exitCode === 0,
+        command,
+        cwd: SANDBOX_WORKSPACE_ROOT,
+        exit_code: result.exitCode,
+        signal: null,
+        timed_out: false,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        stdout_truncated: result.stdoutTruncated,
+        stderr_truncated: result.stderrTruncated
+      }
+    };
+  };
+  const executeReadFileTool = async (rawInput) => {
+    const filePath = String(rawInput.path ?? "").trim();
+    if (!filePath) {
+      throw new Error("path is required");
+    }
+    if (!sessionManager.getSandboxId()) {
+      const hostPath = resolveHostSkillPath(availableSkills, filePath) ?? resolveHostDataPath(referenceFiles, filePath);
+      if (hostPath) {
+        try {
+          const content = await fs4.readFile(hostPath, "utf8");
           setSpanAttributes({
+            "app.sandbox.path.length": filePath.length,
             "app.sandbox.read.bytes": Buffer.byteLength(content, "utf8"),
-            "app.sandbox.read.chars": content.length
+            "app.sandbox.read.chars": content.length,
+            "app.skill.virtual_read": true
           });
           setSpanStatus("ok");
           return {
-            content,
-            path: filePath,
-            success: true
+            result: {
+              content,
+              path: filePath,
+              success: true
+            }
           };
-        }
-      );
-      return { result };
-    }
-    if (params.toolName === "writeFile") {
-      const filePath = String(rawInput.path ?? "").trim();
-      if (!filePath) {
-        throw new Error("path is required");
-      }
-      const content = String(rawInput.content ?? "");
-      const executeWriteFile = (await getToolExecutors()).writeFile;
-      await withSandboxSpan(
-        "sandbox.writeFile",
-        "sandbox.fs.write",
-        {
-          "app.sandbox.path.length": filePath.length,
-          "app.sandbox.write.bytes": Buffer.byteLength(content, "utf8")
-        },
-        async () => {
-          try {
-            await executeWriteFile({ path: filePath, content });
-            setSpanStatus("ok");
-          } catch (error) {
-            throwSandboxOperationError("sandbox writeFile", error);
+        } catch (error) {
+          if (!isHostFileMissingError(error)) {
+            throw error;
           }
         }
-      );
-      return {
-        result: {
-          ok: true,
+      }
+    }
+    logSandboxBootRequest("tool.readFile", {
+      "file.path": filePath
+    });
+    const executeReadFile = (await sessionManager.ensureToolExecutors()).readFile;
+    const result = await withSandboxSpan(
+      "sandbox.readFile",
+      "sandbox.fs.read",
+      {
+        "app.sandbox.path.length": filePath.length
+      },
+      async () => {
+        const response = await executeReadFile({ path: filePath });
+        const content = String(response.content ?? "");
+        setSpanAttributes({
+          "app.sandbox.read.bytes": Buffer.byteLength(content, "utf8"),
+          "app.sandbox.read.chars": content.length
+        });
+        setSpanStatus("ok");
+        return {
+          content,
           path: filePath,
-          bytes_written: Buffer.byteLength(content, "utf8")
-        }
-      };
-    }
-    throw new Error(`unsupported sandbox tool: ${params.toolName}`);
+          success: true
+        };
+      }
+    );
+    return { result };
   };
-  const dispose = async () => {
-    if (!sandbox) {
-      return;
-    }
+  const executeWriteFileTool = async (rawInput) => {
+    const filePath = String(rawInput.path ?? "").trim();
+    if (!filePath) {
+      throw new Error("path is required");
+    }
+    const content = String(rawInput.content ?? "");
+    logSandboxBootRequest("tool.writeFile", {
+      "file.path": filePath
+    });
+    const executeWriteFile = (await sessionManager.ensureToolExecutors()).writeFile;
     await withSandboxSpan(
-      "sandbox.stop",
-      "sandbox.stop",
+      "sandbox.writeFile",
+      "sandbox.fs.write",
       {
-        "app.sandbox.stop.blocking": true
+        "app.sandbox.path.length": filePath.length,
+        "app.sandbox.write.bytes": Buffer.byteLength(content, "utf8")
       },
       async () => {
-        await sandbox.stop({ blocking: true });
+        try {
+          await executeWriteFile({ path: filePath, content });
+        } catch (error) {
+          throwSandboxOperationError("sandbox writeFile", error);
+        }
+        setSpanStatus("ok");
       }
     );
-    sandbox = null;
-    toolExecutors = void 0;
+    return {
+      result: {
+        ok: true,
+        path: filePath,
+        bytes_written: Buffer.byteLength(content, "utf8")
+      }
+    };
+  };
+  const execute = async (params) => {
+    const rawInput = params.input ?? {};
+    const bashCommand = params.toolName === "bash" ? String(rawInput.command ?? "").trim() : void 0;
+    if (params.toolName === "bash") {
+      if (!bashCommand) {
+        throw new Error("command is required");
+      }
+      if (options?.runBashCustomCommand) {
+        const custom = await options.runBashCustomCommand(bashCommand);
+        if (custom.handled) {
+          return { result: custom.result };
+        }
+      }
+      return await executeBashTool(rawInput, bashCommand);
+    }
+    if (params.toolName === "readFile") {
+      return await executeReadFileTool(rawInput);
+    }
+    if (params.toolName === "writeFile") {
+      return await executeWriteFileTool(rawInput);
+    }
+    throw new Error(`unsupported sandbox tool: ${params.toolName}`);
   };
   return {
     configureSkills(skills) {
       availableSkills = [...skills];
+      sessionManager.configureSkills(skills);
+    },
+    configureReferenceFiles(files) {
+      referenceFiles = [...files];
+      sessionManager.configureReferenceFiles(files);
     },
     getSandboxId() {
-      return sandbox?.sandboxId ?? sandboxIdHint;
+      return sessionManager.getSandboxId();
     },
     getDependencyProfileHash() {
-      return dependencyProfileHash;
+      return sessionManager.getDependencyProfileHash();
     },
     canExecute(toolName) {
       return SANDBOX_TOOL_NAMES.has(toolName);
     },
     async createSandbox() {
-      return await acquireSandbox();
+      return createSandboxWorkspace(await sessionManager.createSandbox());
     },
     execute,
-    dispose
+    async dispose() {
+      await sessionManager.dispose();
+    }
   };
 }
@@ -8347,7 +8677,7 @@ function shouldEmitDevAgentTrace() {
 function buildToolStatus(toolName, input) {
   const obj = input && typeof input === "object" ? input : void 0;
   const command = obj ? compactStatusCommand(obj.command) : void 0;
-  const path6 = obj ? compactStatusPath(obj.path) : void 0;
+  const path7 = obj ? compactStatusPath(obj.path) : void 0;
   const filename = obj ? compactStatusFilename(obj.path) : void 0;
   const query = obj ? compactStatusText(obj.query, 70) : void 0;
   const domain = obj ? extractStatusUrlDomain(obj.url) : void 0;
@@ -8362,8 +8692,8 @@ function buildToolStatus(toolName, input) {
   if (filename && toolName === "writeFile") {
     return makeAssistantStatus("updating", filename);
   }
-  if (path6 && toolName === "writeFile") {
-    return makeAssistantStatus("updating", path6);
+  if (path7 && toolName === "writeFile") {
+    return makeAssistantStatus("updating", path7);
   }
   if (skillName && toolName === "loadSkill") {
     return makeAssistantStatus("loading", skillName);
@@ -9156,6 +9486,14 @@ async function generateAssistantReply(messageText, context = {}) {
   let lastKnownSandboxDependencyProfileHash = context.sandbox?.sandboxDependencyProfileHash;
   let loadedSkillNamesForResume = [];
   let mcpToolManager;
+  let sandboxExecutor;
+  const getSandboxMetadata = () => sandboxExecutor ? {
+    sandboxId: sandboxExecutor.getSandboxId(),
+    sandboxDependencyProfileHash: sandboxExecutor.getDependencyProfileHash()
+  } : {
+    sandboxId: lastKnownSandboxId,
+    sandboxDependencyProfileHash: lastKnownSandboxDependencyProfileHash
+  };
   try {
     const shouldTrace = shouldEmitDevAgentTrace();
     const spanContext = {
@@ -9228,7 +9566,7 @@ async function generateAssistantReply(messageText, context = {}) {
       resolveConfiguration: async (key) => configurationValues[key]
     });
     const providerAuthActions = /* @__PURE__ */ new Map();
-    const sandboxExecutor = createSandboxExecutor({
+    sandboxExecutor = createSandboxExecutor({
       sandboxId: context.sandbox?.sandboxId,
       sandboxDependencyProfileHash: context.sandbox?.sandboxDependencyProfileHash,
       traceContext: spanContext,
@@ -9255,10 +9593,53 @@ async function generateAssistantReply(messageText, context = {}) {
         return result.handled ? { handled: true, result: result.result } : { handled: false };
       }
     });
-    lastKnownSandboxId = sandboxExecutor.getSandboxId();
-    lastKnownSandboxDependencyProfileHash = sandboxExecutor.getDependencyProfileHash();
+    const currentSandboxExecutor = sandboxExecutor;
     sandboxExecutor.configureSkills(availableSkills);
-    const sandbox = await sandboxExecutor.createSandbox();
+    sandboxExecutor.configureReferenceFiles(listReferenceFiles());
+    let sandboxPromise;
+    let sandboxPromiseId;
+    const clearSandboxPromise = () => {
+      sandboxPromise = void 0;
+      sandboxPromiseId = void 0;
+    };
+    const getSandbox = (reason) => {
+      const currentSandboxId = currentSandboxExecutor.getSandboxId();
+      if (sandboxPromise && sandboxPromiseId && currentSandboxId !== sandboxPromiseId) {
+        clearSandboxPromise();
+      }
+      if (!sandboxPromise) {
+        logInfo(
+          "sandbox_boot_requested",
+          spanContext,
+          {
+            "app.sandbox.boot.trigger": reason.trigger,
+            ...reason.path ? { "file.path": reason.path } : {},
+            ...reason.cmd ? { "process.executable.name": reason.cmd } : {},
+            ...reason.cwd ? { "file.directory": reason.cwd } : {}
+          },
+          "Lazy sandbox boot requested"
+        );
+        sandboxPromise = currentSandboxExecutor.createSandbox().then((sandbox2) => {
+          sandboxPromiseId = sandbox2.sandboxId;
+          return sandbox2;
+        }).catch((error) => {
+          clearSandboxPromise();
+          throw error;
+        });
+      }
+      return sandboxPromise;
+    };
+    const sandbox = {
+      readFileToBuffer: async (input) => (await getSandbox({
+        trigger: "workspace.readFileToBuffer",
+        path: input.path
+      })).readFileToBuffer(input),
+      runCommand: async (input) => (await getSandbox({
+        trigger: "workspace.runCommand",
+        cmd: input.cmd,
+        cwd: input.cwd
+      })).runCommand(input)
+    };
     for (const skillName of existingCheckpoint?.loadedSkillNames ?? []) {
       const preloaded = await skillSandbox.loadSkill(skillName);
       if (preloaded) {
@@ -9393,20 +9774,37 @@ async function generateAssistantReply(messageText, context = {}) {
         activeSkills,
         invokedSkill
       ),
-      runtimeMetadata: getRuntimeMetadata()
+      runtimeMetadata: getRuntimeMetadata(),
+      threadParticipants: context.threadParticipants
     });
     const userContentParts = [{ type: "text", text: userTurnText }];
     for (const attachment of context.userAttachments ?? []) {
-      if (attachment.mediaType.startsWith("image/")) {
+      if (attachment.promptText) {
+        userContentParts.push({
+          type: "text",
+          text: attachment.promptText
+        });
+      } else if (attachment.mediaType.startsWith("image/")) {
+        if (!attachment.data) {
+          throw new Error("Image attachment is missing image data");
+        }
         userContentParts.push({
           type: "image",
           data: attachment.data.toString("base64"),
           mimeType: attachment.mediaType
         });
       } else {
+        if (!attachment.data) {
+          throw new Error("Attachment is missing attachment data");
+        }
+        const promptAttachment = {
+          data: attachment.data,
+          mediaType: attachment.mediaType,
+          filename: attachment.filename
+        };
         userContentParts.push({
           type: "text",
-          text: encodeNonImageAttachmentForPrompt(attachment)
+          text: encodeNonImageAttachmentForPrompt(promptAttachment)
         });
       }
     }
@@ -9603,8 +10001,8 @@ async function generateAssistantReply(messageText, context = {}) {
       replyFiles,
       artifactStatePatch,
       toolCalls,
-      sandboxId: sandboxExecutor.getSandboxId(),
-      sandboxDependencyProfileHash: sandboxExecutor.getDependencyProfileHash(),
+      sandboxId: currentSandboxExecutor.getSandboxId(),
+      sandboxDependencyProfileHash: currentSandboxExecutor.getDependencyProfileHash(),
       generatedFileCount: generatedFiles.length,
       hasTextDeltaCallback: Boolean(context.onTextDelta),
       shouldTrace,
@@ -9655,8 +10053,7 @@ async function generateAssistantReply(messageText, context = {}) {
     const message = error instanceof Error ? error.message : String(error);
     return {
       text: `Error: ${message}`,
-      sandboxId: lastKnownSandboxId,
-      sandboxDependencyProfileHash: lastKnownSandboxDependencyProfileHash,
+      ...getSandboxMetadata(),
       diagnostics: {
         outcome: "provider_error",
         modelId: botConfig.modelId,
@@ -10260,9 +10657,9 @@ async function GET4(request, provider, waitUntil) {
 }
 // src/chat/slack/app-home.ts
-import fs4 from "fs";
-import path5 from "path";
-var DEFAULT_ABOUT_TEXT = "I help your team investigate, summarize, and act on work in Slack.";
+import fs5 from "fs";
+import path6 from "path";
+var DEFAULT_DESCRIPTION_TEXT = "I help your team investigate, summarize, and act on work in Slack.";
 var MAX_HOME_SKILLS = 6;
 var MAX_SECTION_TEXT_CHARS = 3e3;
 var HIDDEN_HOME_SKILLS = /* @__PURE__ */ new Set(["jr-rpc"]);
@@ -10272,16 +10669,16 @@ function clampSectionText(text) {
   }
   return `${text.slice(0, MAX_SECTION_TEXT_CHARS - 1)}\u2026`;
 }
-function loadAboutText() {
-  const aboutPath = path5.join(homeDir(), "ABOUT.md");
+function loadDescriptionText() {
+  const descriptionPath = path6.join(homeDir(), "DESCRIPTION.md");
   try {
-    const raw = fs4.readFileSync(aboutPath, "utf8").trim();
+    const raw = fs5.readFileSync(descriptionPath, "utf8").trim();
     if (raw.length > 0) {
       return clampSectionText(raw);
     }
   } catch {
   }
-  return DEFAULT_ABOUT_TEXT;
+  return DEFAULT_DESCRIPTION_TEXT;
 }
 async function buildSkillsSummaryText() {
   const skills = (await discoverSkills()).filter(
@@ -10301,7 +10698,10 @@ async function buildSkillsSummaryText() {
 }
 async function hasConnectedAccount(userId, plugin, userTokenStore) {
   if (plugin.manifest.credentials?.type === "oauth-bearer") {
-    return Boolean(await userTokenStore.get(userId, plugin.manifest.name));
+    const stored = await userTokenStore.get(userId, plugin.manifest.name);
+    return Boolean(
+      stored && hasRequiredOAuthScope(stored.scope, plugin.manifest.oauth?.scope)
+    );
   }
   if (plugin.manifest.mcp) {
     return Boolean(
@@ -10312,7 +10712,7 @@ async function hasConnectedAccount(userId, plugin, userTokenStore) {
 }
 async function buildHomeView(userId, userTokenStore) {
   const runtimeMetadata = getRuntimeMetadata();
-  const aboutText = loadAboutText();
+  const descriptionText = loadDescriptionText();
   const skillsSummaryText = await buildSkillsSummaryText();
   const providers = getPluginProviders();
   const connectedSections = [];
@@ -10357,7 +10757,7 @@ ${plugin.manifest.description}`
         type: "section",
         text: {
           type: "mrkdwn",
-          text: aboutText
+          text: descriptionText
         }
       },
       { type: "divider" },
@@ -10564,7 +10964,10 @@ async function GET5(request, provider, waitUntil) {
   const tokenData = await tokenResponse.json();
   let parsedTokenResponse;
   try {
-    parsedTokenResponse = parseOAuthTokenResponse(tokenData);
+    parsedTokenResponse = parseOAuthTokenResponse(
+      tokenData,
+      providerConfig.scope
+    );
   } catch {
     return htmlErrorResponse(
       "Connection failed",
@@ -10572,6 +10975,13 @@ async function GET5(request, provider, waitUntil) {
       500
     );
   }
+  if (!hasRequiredOAuthScope(parsedTokenResponse.scope, providerConfig.scope)) {
+    return htmlErrorResponse(
+      "Connection failed",
+      `The ${providerLabel} authorization did not grant the access Junior requires. Return to Slack and ask Junior to connect your ${providerLabel} account again.`,
+      400
+    );
+  }
   const userTokenStore = createUserTokenStore();
   await userTokenStore.set(stored.userId, provider, parsedTokenResponse);
   waitUntil(async () => {
@@ -10625,7 +11035,7 @@ var replyDecisionSchema = z.object({
 var ROUTER_CONFIDENCE_THRESHOLD = 0.8;
 var LEADING_SLACK_MENTION_RE = /^\s*<@([A-Z0-9]+)(?:\|([^>]+))?>[\s,:-]*/i;
 var LEADING_NAMED_MENTION_RE = /^\s*@([a-z0-9._-]+)\b[\s,:-]*/i;
-var TRANSCRIPT_MESSAGE_LINE_RE = /^\[(assistant|system|user)\]\s+[^:]+:\s+([\s\S]+)$/i;
+var TRANSCRIPT_MESSAGE_LINE_RE = /^\[(assistant|system|user)\]\s+([^:]+):\s+([\s\S]+)$/i;
 var THREAD_OPTOUT_PATTERNS = [
   /\bstop (?:watching|replying|participating)\b/i,
   /\bstay out\b/i,
@@ -10633,6 +11043,11 @@ var THREAD_OPTOUT_PATTERNS = [
   /\bunsubscribe\b/i,
   /\bleave (?:this )?thread\b/i
 ];
+var ACKNOWLEDGMENT_ONLY_RE = /^(?:thanks(?: you)?|thank you|thx|ty|got it|sounds good|sgtm|lgtm|ok(?:ay)?|cool|nice|perfect|awesome|great|makes sense|understood|roger|yep|yup|kk|on it|will do)(?:[.!]+)?$/i;
+var DIRECTED_FOLLOW_UP_CUE_RE = /\b(?:you said|you just said|your last response|your last answer|what did you just say|what do you mean|what did you mean|explain(?: that| this| it| more)?|clarify(?: that| this| it)?|expand(?: on)?(?: that| this| it)?|elaborate(?: on)?(?: that| this| it)?|say more)\b/i;
+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 escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -10669,36 +11084,113 @@ function isThreadOptOutInstruction(rawText, text) {
     (pattern) => pattern.test(rawText) || pattern.test(text)
   );
 }
-function getTranscriptMessageHints(conversationContext) {
+function isAcknowledgmentOnly(text) {
+  return ACKNOWLEDGMENT_ONLY_RE.test(text.trim());
+}
+function hasDirectedFollowUpCue(text) {
+  return DIRECTED_FOLLOW_UP_CUE_RE.test(text.trim());
+}
+function isTerseClarification(text) {
+  return TERSE_CLARIFICATION_RE.test(text.trim());
+}
+function isGenericImmediateSideConversation(text) {
+  const trimmed = text.trim();
+  if (GENERIC_IMMEDIATE_SIDE_CONVERSATION_RE.test(trimmed)) {
+    return true;
+  }
+  if (!trimmed.toLowerCase().startsWith("what about")) {
+    return false;
+  }
+  const wordCount = trimmed.split(/\s+/).map((part) => part.trim()).filter(Boolean).length;
+  return wordCount > 3;
+}
+function parseTranscriptMessages(conversationContext) {
   if (!conversationContext) {
-    return {
-      latestPriorMessageRole: "[none]",
-      latestPriorAssistantMessage: "[none]"
-    };
+    return [];
   }
+  const messages = [];
   const lines = conversationContext.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
-  let latestPriorMessageRole = "[none]";
-  let latestPriorAssistantMessage = "[none]";
-  for (let index = lines.length - 1; index >= 0; index -= 1) {
-    const match = lines[index]?.match(TRANSCRIPT_MESSAGE_LINE_RE);
+  for (const line of lines) {
+    const match = line.match(TRANSCRIPT_MESSAGE_LINE_RE);
     if (!match) {
       continue;
     }
-    if (latestPriorMessageRole === "[none]") {
-      latestPriorMessageRole = match[1].toLowerCase();
-    }
-    if (latestPriorAssistantMessage === "[none]" && match[1].toLowerCase() === "assistant") {
-      latestPriorAssistantMessage = match[2];
+    messages.push({
+      role: match[1].toLowerCase(),
+      author: match[2]?.trim() || "unknown",
+      text: match[3]?.trim() || ""
+    });
+  }
+  return messages;
+}
+function buildRouterSignals(input) {
+  const transcriptMessages = parseTranscriptMessages(input.conversationContext);
+  const recentMessages = transcriptMessages.filter((message) => message.role !== "system").slice(-RECENT_THREAD_WINDOW);
+  const latestPriorMessage = [...transcriptMessages].reverse().find((message) => message.role !== "system");
+  const latestPriorAssistantMessage = [...transcriptMessages].reverse().find((message) => message.role === "assistant");
+  let humanMessagesSinceLastAssistant;
+  let humanMessageCount = 0;
+  for (let index = transcriptMessages.length - 1; index >= 0; index -= 1) {
+    const message = transcriptMessages[index];
+    if (!message || message.role === "system") {
+      continue;
     }
-    if (latestPriorMessageRole !== "[none]" && latestPriorAssistantMessage !== "[none]") {
+    if (message.role === "assistant") {
+      humanMessagesSinceLastAssistant = humanMessageCount;
       break;
     }
+    humanMessageCount += 1;
   }
   return {
-    latestPriorMessageRole,
-    latestPriorAssistantMessage
+    assistantWasLastSpeaker: latestPriorMessage?.role === "assistant",
+    currentMessageHasDirectedFollowUpCue: hasDirectedFollowUpCue(input.text),
+    currentMessageHasAttachments: Boolean(input.hasAttachments),
+    currentMessageIsTerseClarification: isTerseClarification(input.text),
+    humanMessagesSinceLastAssistant,
+    latestPriorAssistantMessage: latestPriorAssistantMessage?.text || "[none]",
+    latestPriorMessageRole: latestPriorMessage?.role || "[none]",
+    recentMessages
   };
 }
+function buildRouterPrompt(rawText, signals) {
+  const recentThread = signals.recentMessages.length > 0 ? signals.recentMessages.map(
+    (message) => escapeXml(`[${message.role}] ${message.author}: ${message.text}`)
+  ).join("\n") : "[none]";
+  return [
+    `<latest-message>${escapeXml(rawText.trim() || "[attachment-only message]")}</latest-message>`,
+    "<routing-signals>",
+    `assistant_was_last_speaker=${signals.assistantWasLastSpeaker ? "true" : "false"}`,
+    `human_messages_since_last_assistant=${signals.humanMessagesSinceLastAssistant ?? "none"}`,
+    `latest_prior_message_role=${escapeXml(signals.latestPriorMessageRole)}`,
+    `current_message_has_directed_follow_up_cue=${signals.currentMessageHasDirectedFollowUpCue ? "true" : "false"}`,
+    `current_message_is_terse_clarification=${signals.currentMessageIsTerseClarification ? "true" : "false"}`,
+    `current_message_has_attachments=${signals.currentMessageHasAttachments ? "true" : "false"}`,
+    "</routing-signals>",
+    `<latest-prior-assistant-message>${escapeXml(
+      signals.latestPriorAssistantMessage
+    )}</latest-prior-assistant-message>`,
+    "<recent-thread>",
+    recentThread,
+    "</recent-thread>"
+  ].join("\n");
+}
+function getReplyConfidenceThreshold(signals) {
+  let threshold = ROUTER_CONFIDENCE_THRESHOLD;
+  if (signals.assistantWasLastSpeaker && signals.humanMessagesSinceLastAssistant === 0) {
+    if (signals.currentMessageHasDirectedFollowUpCue || signals.currentMessageIsTerseClarification) {
+      threshold = 0.65;
+    } else {
+      threshold = 0.9;
+    }
+  } else if (signals.humanMessagesSinceLastAssistant === 1) {
+    threshold = signals.currentMessageHasDirectedFollowUpCue ? 0.8 : 0.9;
+  } else if (signals.humanMessagesSinceLastAssistant === void 0) {
+    threshold = 0.85;
+  } else if (signals.humanMessagesSinceLastAssistant >= 2) {
+    threshold = 0.9;
+  }
+  return Math.max(0.6, Math.min(0.9, threshold));
+}
 function getSubscribedReplyPreflightDecision(args) {
   const text = args.text.trim();
   const rawText = args.rawText.trim();
@@ -10719,54 +11211,27 @@ function getSubscribedReplyPreflightDecision(args) {
     reasonDetail: leadingOtherPartyAddress
   };
 }
-function buildRouterSystemPrompt(botUserName, conversationContext, isExplicitMention) {
-  const { latestPriorMessageRole, latestPriorAssistantMessage } = getTranscriptMessageHints(conversationContext);
+function buildRouterSystemPrompt(botUserName) {
   return [
     "You are a message router for a Slack assistant named Junior in a subscribed Slack thread.",
     "Decide whether Junior should reply to the latest message.",
     "Subscribed threads are passive by default.",
-    "Default to should_reply=false unless the user is clearly asking Junior for help or follow-up.",
-    "A direct @mention is a strong signal to reply unless the message is clearly telling Junior to stop participating.",
-    "",
-    "Reply should be true only when the user is clearly asking Junior a question, requesting help,",
-    "or when a direct follow-up is contextually aimed at Junior's previous response in the thread context.",
-    "",
-    "Reply should be false for side conversations between humans, acknowledgements,",
-    "status chatter, or messages not seeking assistant input.",
-    "Junior must not participate in casual banter or keep chiming in just because it replied earlier.",
-    "",
-    "Examples of messages Junior should NOT reply to (should_reply=false):",
-    "- Questions between humans: 'Is that the right approach?', 'Can you check on this?', 'Did you deploy that?'",
-    "- Acknowledgments: 'thanks', '+1', 'lgtm', 'ok cool', 'sounds good', 'nice'",
-    "- Status updates: 'I just pushed a fix', 'Deploying now', 'Build is green'",
-    "- General thread discussion: 'What about the billing issue?', 'I think we should revert'",
-    "- Reactions to work: 'That looks wrong', 'Nice catch', 'Hmm interesting'",
-    "",
-    "Examples of messages Junior SHOULD reply to (should_reply=true):",
-    "- Direct follow-ups to Junior's response: 'Can you explain that last point in more detail?'",
-    "- Self-referential follow-ups after Junior just answered: 'What did you just say about the budget?', 'Can you explain your last response in more detail?'",
-    "- Explicit requests for Junior's help: 'Junior, what's causing this error?'",
-    "",
-    "Treat a message as directed at Junior when it explicitly refers to Junior's immediately previous reply",
-    "using language like 'you just said', 'your last response', 'your last answer', or similar self-reference.",
-    "Do not confuse that with general topic continuation. A message like 'What about the billing worker timeline?'",
-    "still should_reply=false unless it clearly asks Junior for help.",
-    "",
-    "When in doubt, should_reply=false. Most messages in a thread are human-to-human conversation.",
-    "",
-    "If the user is clearly telling Junior to stop watching, replying, or participating in the thread,",
-    "set should_unsubscribe=true and should_reply=false.",
-    "Use should_unsubscribe only for clear thread opt-out instructions, not for ordinary side conversation.",
-    "If uncertain, set should_reply=false and use low confidence.",
+    "Reply true only when the latest message is aimed at Junior.",
+    "Use who currently has the conversation floor, not just topic overlap.",
+    "If Junior was the last speaker, only a clear turn back to Junior should count as an implicit follow-up.",
+    "Terse clarifications like 'which one?' or 'why?' right after Junior answers can be should_reply=true.",
+    "Direct self-reference to Junior's prior answer like 'what did you just say?' or 'explain that more' can be should_reply=true.",
+    "If one or more humans spoke after Junior, require a clear turn back to Junior. Shared domain vocabulary alone is not enough.",
+    "Questions like 'what about auth?' or 'can you check on this?' are usually human-to-human unless the thread clearly turns back to Junior.",
+    "A vague question like 'is that the right approach?' is still should_reply=false unless it clearly turns back to Junior.",
+    "Acknowledgments, reactions, status chatter, and team coordination should be should_reply=false.",
+    "If the latest message clearly tells Junior to stop watching, replying, or participating, set should_unsubscribe=true and should_reply=false.",
+    "When uncertain, prefer should_reply=false with low confidence.",
     "",
     "Return JSON with should_reply, should_unsubscribe, confidence, and a short reason.",
     "Do not return any extra keys.",
     "",
-    `<assistant-name>${escapeXml(botUserName)}</assistant-name>`,
-    `<explicit-mention>${isExplicitMention ? "true" : "false"}</explicit-mention>`,
-    `<latest-prior-message-role>${escapeXml(latestPriorMessageRole)}</latest-prior-message-role>`,
-    `<latest-prior-assistant-message>${escapeXml(latestPriorAssistantMessage)}</latest-prior-assistant-message>`,
-    `<thread-context>${escapeXml(conversationContext?.trim() || "[none]")}</thread-context>`
+    `<assistant-name>${escapeXml(botUserName)}</assistant-name>`
   ].join("\n");
 }
 async function decideSubscribedThreadReply(args) {
@@ -10781,11 +11246,16 @@ async function decideSubscribedThreadReply(args) {
   if (preflightDecision) {
     return preflightDecision;
   }
+  const signals = buildRouterSignals(args.input);
   if (!text && !args.input.hasAttachments) {
     return { shouldReply: false, reason: "empty_message" /* EmptyMessage */ };
   }
-  if (!text && args.input.hasAttachments) {
-    return { shouldReply: true, reason: "attachment_only" /* AttachmentOnly */ };
+  if (!args.input.isExplicitMention && !args.input.hasAttachments && isAcknowledgmentOnly(text)) {
+    return {
+      shouldReply: false,
+      reason: "side_conversation" /* SideConversation */,
+      reasonDetail: "acknowledgment"
+    };
   }
   if (args.input.isExplicitMention) {
     if (isThreadOptOutInstruction(rawText, text)) {
@@ -10801,18 +11271,21 @@ async function decideSubscribedThreadReply(args) {
       reason: "explicit_mention" /* ExplicitMention */
     };
   }
+  if (signals.assistantWasLastSpeaker && signals.humanMessagesSinceLastAssistant === 0 && !signals.currentMessageHasAttachments && !signals.currentMessageHasDirectedFollowUpCue && !signals.currentMessageIsTerseClarification && isGenericImmediateSideConversation(text)) {
+    return {
+      shouldReply: false,
+      reason: "side_conversation" /* SideConversation */,
+      reasonDetail: "generic immediate side conversation"
+    };
+  }
   try {
     const result = await args.completeObject({
       modelId: args.modelId,
       schema: replyDecisionSchema,
       maxTokens: 120,
       temperature: 0,
-      system: buildRouterSystemPrompt(
-        args.botUserName,
-        args.input.conversationContext,
-        args.input.isExplicitMention
-      ),
-      prompt: rawText,
+      system: buildRouterSystemPrompt(args.botUserName),
+      prompt: buildRouterPrompt(rawText, signals),
       metadata: {
         modelId: args.modelId,
         threadId: args.input.context.threadId ?? "",
@@ -10823,6 +11296,7 @@ async function decideSubscribedThreadReply(args) {
     });
     const parsed = replyDecisionSchema.parse(result.object);
     const reason = parsed.reason?.trim() || "classifier";
+    const replyConfidenceThreshold = getReplyConfidenceThreshold(signals);
     if (parsed.should_unsubscribe) {
       if (parsed.confidence < ROUTER_CONFIDENCE_THRESHOLD) {
         return {
@@ -10845,7 +11319,7 @@ async function decideSubscribedThreadReply(args) {
         reasonDetail: reason
       };
     }
-    if (parsed.confidence < ROUTER_CONFIDENCE_THRESHOLD) {
+    if (parsed.confidence < replyConfidenceThreshold) {
       return {
         shouldReply: false,
         reason: "low_confidence" /* LowConfidence */,
@@ -11440,16 +11914,166 @@ var MAX_USER_ATTACHMENTS = 3;
 var MAX_USER_ATTACHMENT_BYTES = 5 * 1024 * 1024;
 var MAX_MESSAGE_IMAGE_ATTACHMENTS = 3;
 var MAX_VISION_SUMMARY_CHARS = 500;
-async function resolveUserAttachments(attachments, context) {
+function isVisionEnabled() {
+  return Boolean(botConfig.visionModelId);
+}
+var ImageAttachmentProcessingError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ImageAttachmentProcessingError";
+  }
+};
+function buildImageAttachmentPromptText(args) {
+  return [
+    "<image-attachment>",
+    `filename: ${args.filename ?? "unnamed"}`,
+    `media_type: ${args.mediaType}`,
+    "<summary>",
+    args.summary,
+    "</summary>",
+    "</image-attachment>"
+  ].join("\n");
+}
+async function summarizeImageWithVision(args) {
+  const visionModelId = botConfig.visionModelId;
+  if (!visionModelId) {
+    return void 0;
+  }
+  const result = await args.completeText({
+    modelId: visionModelId,
+    temperature: 0,
+    maxTokens: args.maxTokens,
+    messages: [
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: args.prompt
+          },
+          {
+            type: "image",
+            data: args.imageData.toString("base64"),
+            mimeType: args.mimeType
+          }
+        ],
+        timestamp: Date.now()
+      }
+    ],
+    metadata: {
+      modelId: visionModelId,
+      ...args.metadata
+    }
+  });
+  const summary = result.text.trim().replace(/\s+/g, " ");
+  return summary || void 0;
+}
+function truncateVisionSummary(summary) {
+  return summary.slice(0, MAX_VISION_SUMMARY_CHARS);
+}
+function getCachedImageSummaries(args) {
+  if (!args.conversation || !args.messageTs) {
+    return [];
+  }
+  const conversationMessage = args.conversation.messages.find(
+    (message) => getConversationMessageSlackTs(message) === args.messageTs
+  );
+  if (!conversationMessage) {
+    return [];
+  }
+  return (conversationMessage.meta?.imageFileIds ?? []).map(
+    (fileId) => args.conversation?.vision.byFileId[fileId]?.summary?.trim()
+  );
+}
+function createImageAttachmentProcessingError(attachment) {
+  const label = attachment.filename ? `"${attachment.filename}"` : "this image";
+  return new ImageAttachmentProcessingError(
+    `Image attachment ${label} could not be analyzed`
+  );
+}
+async function resolveUserAttachmentsWithDeps(attachments, context, deps) {
   if (!attachments || attachments.length === 0) {
     return [];
   }
   const results = [];
+  const cachedImageSummaries = getCachedImageSummaries({
+    conversation: context.conversation,
+    messageTs: context.messageTs
+  });
+  let nextCachedImageSummaryIndex = 0;
   for (const attachment of attachments) {
     if (results.length >= MAX_USER_ATTACHMENTS) break;
     if (attachment.type !== "image" && attachment.type !== "file") continue;
     const mediaType = attachment.mimeType ?? "application/octet-stream";
+    const isImageAttachment = attachment.type === "image" || mediaType.startsWith("image/");
+    if (isImageAttachment && !isVisionEnabled()) {
+      continue;
+    }
     try {
+      const resolvedAttachment = {
+        mediaType,
+        filename: attachment.name
+      };
+      if (isImageAttachment) {
+        const cachedSummary = cachedImageSummaries[nextCachedImageSummaryIndex];
+        nextCachedImageSummaryIndex += 1;
+        if (cachedSummary) {
+          resolvedAttachment.promptText = buildImageAttachmentPromptText({
+            filename: attachment.name,
+            mediaType,
+            summary: cachedSummary
+          });
+          results.push(resolvedAttachment);
+          continue;
+        }
+        let imageData = null;
+        if (attachment.fetchData) {
+          imageData = await attachment.fetchData();
+        } else if (attachment.data instanceof Buffer) {
+          imageData = attachment.data;
+        }
+        if (!imageData) {
+          throw createImageAttachmentProcessingError({
+            filename: attachment.name
+          });
+        }
+        if (imageData.byteLength > MAX_USER_ATTACHMENT_BYTES) {
+          throw createImageAttachmentProcessingError({
+            filename: attachment.name
+          });
+        }
+        const summary = await summarizeImageWithVision({
+          completeText: deps.completeText,
+          imageData,
+          mimeType: mediaType,
+          maxTokens: 220,
+          prompt: [
+            "Extract concise, factual context from this user-provided image.",
+            "Focus on visible text, UI state, charts, diagrams, errors, names, and other concrete details useful for answering the user's current request.",
+            "Do not speculate.",
+            "Return plain text only."
+          ].join(" "),
+          metadata: {
+            threadId: context.threadId ?? "",
+            channelId: context.channelId ?? "",
+            requesterId: context.requesterId ?? "",
+            runId: context.runId ?? "",
+            filename: attachment.name ?? ""
+          }
+        });
+        if (!summary) {
+          throw createImageAttachmentProcessingError({
+            filename: attachment.name
+          });
+        }
+        resolvedAttachment.promptText = buildImageAttachmentPromptText({
+          filename: attachment.name,
+          mediaType,
+          summary: truncateVisionSummary(summary)
+        });
+        results.push(resolvedAttachment);
+        continue;
+      }
       let data = null;
       if (attachment.fetchData) {
         data = await attachment.fetchData();
@@ -11476,12 +12100,32 @@ async function resolveUserAttachments(attachments, context) {
         );
         continue;
       }
-      results.push({
-        data,
-        mediaType,
-        filename: attachment.name
-      });
+      resolvedAttachment.data = data;
+      results.push(resolvedAttachment);
     } catch (error) {
+      if (isImageAttachment) {
+        const attachmentError = error instanceof ImageAttachmentProcessingError ? error : createImageAttachmentProcessingError({
+          filename: attachment.name
+        });
+        logWarn(
+          "image_attachment_processing_failed",
+          {
+            slackThreadId: context.threadId,
+            slackUserId: context.requesterId,
+            slackChannelId: context.channelId,
+            runId: context.runId,
+            assistantUserName: botConfig.userName,
+            modelId: botConfig.visionModelId ?? botConfig.modelId
+          },
+          {
+            "error.message": error instanceof Error ? error.message : String(error),
+            "file.mime_type": mediaType,
+            ...attachment.name ? { "file.name": attachment.name } : {}
+          },
+          "Image attachment processing failed"
+        );
+        throw attachmentError;
+      }
       logWarn(
         "attachment_resolution_failed",
         {
@@ -11503,35 +12147,23 @@ async function resolveUserAttachments(attachments, context) {
   return results;
 }
 async function summarizeConversationImage(args, deps) {
+  const visionModelId = botConfig.visionModelId;
+  if (!visionModelId) {
+    return void 0;
+  }
   try {
-    const result = await deps.completeText({
-      modelId: botConfig.modelId,
-      temperature: 0,
+    const summary = await summarizeImageWithVision({
+      completeText: deps.completeText,
+      imageData: args.imageData,
+      mimeType: args.mimeType,
       maxTokens: 220,
-      messages: [
-        {
-          role: "user",
-          content: [
-            {
-              type: "text",
-              text: [
-                "Extract concise, factual context from this image for future thread turns.",
-                "Focus on visible text, names, titles, companies, and candidate-identifying details.",
-                "Do not speculate.",
-                "Return plain text only."
-              ].join(" ")
-            },
-            {
-              type: "image",
-              data: args.imageData.toString("base64"),
-              mimeType: args.mimeType
-            }
-          ],
-          timestamp: Date.now()
-        }
-      ],
+      prompt: [
+        "Extract concise, factual context from this image for future thread turns.",
+        "Focus on visible text, names, titles, companies, and candidate-identifying details.",
+        "Do not speculate.",
+        "Return plain text only."
+      ].join(" "),
       metadata: {
-        modelId: botConfig.modelId,
         threadId: args.context.threadId ?? "",
         channelId: args.context.channelId ?? "",
         requesterId: args.context.requesterId ?? "",
@@ -11539,11 +12171,10 @@ async function summarizeConversationImage(args, deps) {
         fileId: args.fileId
       }
     });
-    const summary = result.text.trim().replace(/\s+/g, " ");
     if (!summary) {
       return void 0;
     }
-    return summary.slice(0, MAX_VISION_SUMMARY_CHARS);
+    return truncateVisionSummary(summary);
   } catch (error) {
     logWarn(
       "conversation_image_vision_failed",
@@ -11553,7 +12184,7 @@ async function summarizeConversationImage(args, deps) {
         slackChannelId: args.context.channelId,
         runId: args.context.runId,
         assistantUserName: botConfig.userName,
-        modelId: botConfig.modelId
+        modelId: visionModelId
       },
       {
         "error.message": error instanceof Error ? error.message : String(error),
@@ -11566,6 +12197,9 @@ async function summarizeConversationImage(args, deps) {
   }
 }
 async function hydrateConversationVisionContextWithDeps(conversation, context, deps) {
+  if (!isVisionEnabled()) {
+    return;
+  }
   if (!context.channelId || !context.threadTs) {
     return;
   }
@@ -11766,6 +12400,7 @@ async function hydrateConversationVisionContextWithDeps(conversation, context, d
 }
 function createVisionContextService(deps) {
   return {
+    resolveUserAttachments: async (attachments, context) => await resolveUserAttachmentsWithDeps(attachments, context, deps),
     hydrateConversationVisionContext: async (conversation, context) => await hydrateConversationVisionContextWithDeps(
       conversation,
       context,
@@ -11859,6 +12494,19 @@ function getExecutionFailureReason(reply) {
   }
   return "empty assistant turn";
 }
+function buildParticipants(messages) {
+  const seen = /* @__PURE__ */ new Set();
+  const participants = [];
+  for (const message of messages) {
+    const { userId, userName, fullName } = message.author ?? {};
+    if (!userId || message.author?.isBot) continue;
+    if (!seen.has(userId)) {
+      seen.add(userId);
+      participants.push({ userId, userName, fullName });
+    }
+  }
+  return participants;
+}
 function createReplyToThread(deps) {
   return async function replyToThread(thread, message, options = {}) {
     if (message.author.isMe) {
@@ -11901,6 +12549,7 @@ function createReplyToThread(deps) {
             runId
           }
         });
+        const slackMessageTs = getSlackMessageTs(message);
         const turnId = buildDeterministicTurnId(message.id);
         startActiveTurn({
           conversation: preparedState.conversation,
@@ -11945,13 +12594,15 @@ function createReplyToThread(deps) {
         if (resolvedUserName) {
           setTags({ slackUserName: resolvedUserName });
         }
-        const userAttachments = await resolveUserAttachments(
+        const userAttachments = await deps.resolveUserAttachments(
           message.attachments,
           {
             threadId,
             requesterId: message.author.userId,
             channelId,
-            runId
+            runId,
+            conversation: preparedState.conversation,
+            messageTs: slackMessageTs
           }
         );
         const progress = createProgressReporter({
@@ -12015,6 +12666,9 @@ function createReplyToThread(deps) {
         let shouldPersistFailureState = true;
         try {
           const toolChannelId = preparedState.artifacts.assistantContextChannelId ?? channelId;
+          const threadParticipants = buildParticipants(
+            preparedState.conversation.messages
+          );
           const reply = await deps.services.generateAssistantReply(userText, {
             assistant: {
               userName: botConfig.userName
@@ -12044,6 +12698,7 @@ function createReplyToThread(deps) {
               sandboxId: preparedState.sandboxId,
               sandboxDependencyProfileHash: preparedState.sandboxDependencyProfileHash
             },
+            threadParticipants,
             onStatus: (status) => progress.setStatus(status),
             onTextDelta: (deltaText) => {
               if (explicitChannelPostIntent) {
@@ -12340,6 +12995,7 @@ function createPrepareTurnState(deps) {
       }
     );
     const normalizedUserText = normalizeConversationText(args.userText) || "[non-text message]";
+    const slackTs = getSlackMessageTs(args.message);
     const incomingUserMessage = {
       id: args.message.id,
       role: "user",
@@ -12353,7 +13009,7 @@ function createPrepareTurnState(deps) {
       },
       meta: {
         explicitMention: args.explicitMention,
-        slackTs: args.message.id,
+        slackTs,
         imagesHydrated: !messageHasPotentialImageAttachment
       }
     };
@@ -12361,7 +13017,7 @@ function createPrepareTurnState(deps) {
       conversation,
       incomingUserMessage
     );
-    if (messageHasPotentialImageAttachment || !conversation.vision.backfillCompletedAtMs) {
+    if (isVisionEnabled() && (!conversation.vision.backfillCompletedAtMs || messageHasPotentialImageAttachment)) {
       await deps.hydrateConversationVisionContext(conversation, {
         threadId: args.context.threadId,
         channelId: args.context.channelId,
@@ -12408,6 +13064,7 @@ function createSlackRuntime(options) {
   const replyToThread = createReplyToThread({
     getSlackAdapter: options.getSlackAdapter,
     prepareTurnState,
+    resolveUserAttachments: services.visionContext.resolveUserAttachments,
     services: services.replyExecutor
   });
   return createSlackTurnRuntime({
@@ -12439,6 +13096,7 @@ function createSlackRuntime(options) {
     }) => {
       const conversation = coerceThreadConversationState(await thread.state);
       const normalizedUserText = normalizeConversationText(userText) || "[non-text message]";
+      const slackTs = getSlackMessageTs(message);
       upsertConversationMessage(conversation, {
         id: message.id,
         role: "user",
@@ -12452,7 +13110,7 @@ function createSlackRuntime(options) {
         },
         meta: {
           explicitMention: Boolean(message.isMention),
-          slackTs: message.id,
+          slackTs,
           replied: false,
           skippedReason: decision.reason,
           imagesHydrated: true
@@ -12974,9 +13632,121 @@ function getProductionBot() {
   return productionBot;
 }
+// src/chat/ingress/message-changed.ts
+import { Message } from "chat";
+function getEditedMentionMessageId(messageTs) {
+  return `${messageTs}:message_changed_mention`;
+}
+function isMessageChangedEnvelope(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  if (v.type !== "event_callback") return false;
+  const event = v.event;
+  if (!event || typeof event !== "object") return false;
+  return event.type === "message" && event.subtype === "message_changed" && typeof event.channel === "string" && typeof event.message === "object" && event.message !== null && typeof event.previous_message === "object" && event.previous_message !== null;
+}
+function textMentionsBot(text, botUserId) {
+  return text.includes(`<@${botUserId}>`);
+}
+function extractMessageChangedMention(body, botUserId, adapter) {
+  if (!isMessageChangedEnvelope(body)) return null;
+  const { event } = body;
+  const newText = event.message.text ?? "";
+  const prevText = event.previous_message.text ?? "";
+  if (!textMentionsBot(newText, botUserId)) return null;
+  if (textMentionsBot(prevText, botUserId)) return null;
+  const channelId = event.channel;
+  const messageTs = event.message.ts;
+  const threadTs = event.message.thread_ts ?? messageTs;
+  const userId = event.message.user ?? "unknown";
+  const threadId = `slack:${channelId}:${threadTs}`;
+  const raw = {
+    channel: channelId,
+    ts: messageTs,
+    thread_ts: threadTs,
+    user: userId
+  };
+  const message = new Message({
+    id: getEditedMentionMessageId(messageTs),
+    threadId,
+    text: newText,
+    isMention: true,
+    attachments: [],
+    metadata: { dateSent: new Date(Number(messageTs) * 1e3), edited: true },
+    formatted: { type: "root", children: [] },
+    raw,
+    author: {
+      userId,
+      userName: userId,
+      fullName: userId,
+      isBot: false,
+      isMe: false
+    }
+  });
+  Object.defineProperty(message, "adapter", {
+    configurable: true,
+    enumerable: false,
+    value: adapter,
+    writable: true
+  });
+  return { threadId, message };
+}
 // src/handlers/webhooks.ts
-async function POST(request, platform, waitUntil) {
-  const bot = getProductionBot();
+function getSlackPayloadTeamId(body) {
+  if (!body || typeof body !== "object") {
+    return void 0;
+  }
+  const teamId = body.team_id;
+  return typeof teamId === "string" && teamId.length > 0 ? teamId : void 0;
+}
+async function handleAuthenticatedSlackMessageChangedMention(args) {
+  const slackAdapter = args.bot.getAdapter("slack");
+  const authAdapter = slackAdapter;
+  const timestamp = args.request.headers.get("x-slack-request-timestamp");
+  const signature = args.request.headers.get("x-slack-signature");
+  if (!authAdapter.verifySignature(args.rawBody, timestamp, signature)) {
+    return;
+  }
+  const webhookOptions = {
+    waitUntil: (task) => args.waitUntil(task)
+  };
+  const dispatch = () => {
+    const botUserId = authAdapter.botUserId;
+    if (!botUserId) {
+      return false;
+    }
+    const result = extractMessageChangedMention(
+      args.body,
+      botUserId,
+      slackAdapter
+    );
+    if (!result) {
+      return false;
+    }
+    args.bot.processMessage(
+      slackAdapter,
+      result.threadId,
+      result.message,
+      webhookOptions
+    );
+    return true;
+  };
+  if (authAdapter.defaultBotToken) {
+    dispatch();
+    return;
+  }
+  const teamId = getSlackPayloadTeamId(args.body);
+  if (!teamId || !authAdapter.resolveTokenForTeam || !authAdapter.requestContext) {
+    return;
+  }
+  const context = await authAdapter.resolveTokenForTeam(teamId);
+  if (!context) {
+    return;
+  }
+  authAdapter.requestContext.run(context, dispatch);
+}
+async function handlePlatformWebhook(request, platform, waitUntil, bot = getProductionBot()) {
   const handler = bot.webhooks[platform];
   const requestContext = createRequestContext(request, { platform });
   const requestUrl = new URL(request.url);
@@ -12994,6 +13764,34 @@ async function POST(request, platform, waitUntil) {
       );
       return new Response(`Unknown platform: ${platform}`, { status: 404 });
     }
+    let rebuiltRequest = request;
+    if (platform === "slack") {
+      const rawBody = await request.text();
+      let parsedBody;
+      try {
+        parsedBody = JSON.parse(rawBody);
+      } catch {
+        parsedBody = void 0;
+      }
+      if (parsedBody && isMessageChangedEnvelope(parsedBody)) {
+        try {
+          await handleAuthenticatedSlackMessageChangedMention({
+            body: parsedBody,
+            bot,
+            rawBody,
+            request,
+            waitUntil
+          });
+        } catch (error) {
+          logException(error, "slack_message_changed_side_channel_failed");
+        }
+      }
+      rebuiltRequest = new Request(request.url, {
+        method: request.method,
+        headers: request.headers,
+        body: rawBody
+      });
+    }
     try {
       return await withSpan(
         "http.server.request",
@@ -13001,7 +13799,7 @@ async function POST(request, platform, waitUntil) {
         requestContext,
         async () => {
           try {
-            const response = await handler(request, {
+            const response = await handler(rebuiltRequest, {
               waitUntil: (task) => waitUntil(task)
             });
             if (response.status >= 400) {
@@ -13047,6 +13845,9 @@ async function POST(request, platform, waitUntil) {
     }
   });
 }
+async function POST(request, platform, waitUntil) {
+  return handlePlatformWebhook(request, platform, waitUntil);
+}
 // src/app.ts
 async function defaultWaitUntil() {