@sentry/junior 0.19.0 → 0.20.0

package/dist/app.js

@@ -5,9 +5,8 @@ import {
   listCapabilityProviders,
   loadSkillsByName,
   logCapabilityCatalogLoadedOnce,
-  parseSkillInvocation,
-  stripFrontmatter
-} from "./chunk-4XWTSMRF.js";
+  parseSkillInvocation
+} from "./chunk-VJLT6LLV.js";
 import {
   SANDBOX_SKILLS_ROOT,
   SANDBOX_WORKSPACE_ROOT,
@@ -25,8 +24,9 @@ import {
   resolveRuntimeDependencySnapshot,
   runNonInteractiveCommand,
   sandboxSkillDir,
+  sandboxSkillFile,
   toOptionalTrimmed
-} from "./chunk-XYOKYK6U.js";
+} from "./chunk-LOTYK7IE.js";
 import {
   CredentialUnavailableError,
   buildOAuthTokenRequest,
@@ -5021,7 +5021,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 +5029,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 +5042,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 +5054,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 +5067,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 +6806,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 +6862,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 +6966,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 +7330,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 path4 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 +7512,8 @@ if (args[0] === "api") {
     outputJson({ items: [] });
     process.exit(0);
   }
+  outputJson({});
+  process.exit(0);
 }
 
 if (args[0] === "issue") {
@@ -7558,7 +7555,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,156 +7598,315 @@ 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 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 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]
-  });
-}
-function sleep2(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-function isAlreadyExistsError(error) {
-  const details = getSandboxErrorDetails(error);
-  return details.searchableText.includes("already exists") || details.searchableText.includes("file exists") || details.searchableText.includes("eexist");
+  return files;
 }
-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);
-    if (typeof current === "object") {
-      current = current.cause;
-    } else {
-      current = void 0;
+async function buildSkillSyncFiles(availableSkills, runtimeBinDir) {
+  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)
+    });
   }
-  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");
+  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: `${runtimeBinDir}/gh`,
+      content: Buffer.from(buildEvalGitHubCliStub(), "utf8")
+    });
+  }
+  return filesToWrite;
 }
-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 collectDirectories(filesToWrite, workspaceRoot) {
+  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);
     }
-    seen.add(current);
-    current = typeof current === "object" ? current.cause : void 0;
   }
-  return void 0;
+  return Array.from(directoriesToEnsure).filter(
+    (directory) => directory === workspaceRoot || directory.startsWith(`${workspaceRoot}/`)
+  ).sort((a, b) => a.length - b.length);
 }
-function wrapSandboxSetupError(error) {
-  try {
-    const details = getSandboxErrorDetails(error);
-    if (details.summary) {
-      return new Error(`sandbox setup failed (${details.summary})`, {
-        cause: error
-      });
+function resolveHostSkillPath(availableSkills, sandboxPath) {
+  const normalizedPath = path4.posix.normalize(sandboxPath.trim());
+  for (const skill of availableSkills) {
+    const virtualRoot = sandboxSkillDir(skill.name);
+    if (normalizedPath !== virtualRoot && !normalizedPath.startsWith(`${virtualRoot}/`)) {
+      continue;
     }
-  } catch {
+    const relativePath = path4.posix.relative(virtualRoot, normalizedPath);
+    if (!relativePath || relativePath.startsWith("../")) {
+      return null;
+    }
+    const hostRoot = path4.resolve(skill.skillPath);
+    const hostPath = path4.resolve(hostRoot, ...relativePath.split("/"));
+    if (hostPath !== hostRoot && !hostPath.startsWith(`${hostRoot}${path4.sep}`)) {
+      return null;
+    }
+    return hostPath;
   }
-  let causeMessage;
-  try {
-    causeMessage = getFirstErrorMessage(error);
-  } catch (cause) {
-    causeMessage = cause instanceof Error ? cause.message : void 0;
+  return null;
+}
+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
+      );
+      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);
+          }
+        }
+      );
+    }
+  );
+}
+
+// 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 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) => {
-    for (let attempt = 0; attempt < SNAPSHOT_BOOT_RETRY_COUNT; attempt += 1) {
-      try {
-        await onStatus?.(makeAssistantStatus("loading", "sandbox"));
-        return await Sandbox.create({
-          timeout: timeoutMs,
-          source: {
-            type: "snapshot",
-            snapshotId
-          },
-          ...sandboxCredentials ?? {}
-        });
-      } catch (error) {
-        if (!isSnapshottingError(error) || attempt === SNAPSHOT_BOOT_RETRY_COUNT - 1) {
-          throw error;
+  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,
+      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;
+          }
         }
-        await sleep2(SNAPSHOT_BOOT_RETRY_DELAY_MS);
       }
-    }
-    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;
+      clearSession();
     }
     logWarn(
       "sandbox_network_policy_restore_failed",
@@ -7763,290 +7921,304 @@ function createSandboxExecutor(options) {
     } 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
+  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 {
+        if (emitStatus) {
+          await emitSandboxStatus(
+            "snapshot_boot",
+            emitStatus,
+            makeAssistantStatus("loading", "sandbox")
+          );
+        }
+        return await Sandbox.create({
+          timeout: timeoutMs,
+          source: {
+            type: "snapshot",
+            snapshotId
           },
-          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);
-            }
-          }
-        );
+          ...sandboxCredentials ?? {}
+        });
+      } catch (error) {
+        if (!isSnapshottingError(error) || attempt === SNAPSHOT_BOOT_RETRY_COUNT - 1) {
+          throw error;
+        }
+        await sleep2(SNAPSHOT_BOOT_RETRY_DELAY_MS);
       }
-    );
+    }
+    throw new Error(`Failed to boot sandbox from snapshot ${snapshotId}`);
+  };
+  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 ?? {}
+      });
+    }
+    try {
+      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 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
+          });
+        }
+      );
+    } 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 withSandboxSpan(
+    return await withSandboxSpan(
       "sandbox.acquire",
       "sandbox.acquire",
       {
         "app.sandbox.id_hint_present": Boolean(sandboxIdHint),
         "app.sandbox.timeout_ms": timeoutMs,
-        "app.sandbox.runtime": "node22",
+        "app.sandbox.runtime": SANDBOX_RUNTIME,
         "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);
-          }
+        discardHintIfProfileChanged();
+        const cachedSandbox = await tryReuseCachedSandbox();
+        if (cachedSandbox) {
+          return cachedSandbox;
         }
-        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;
-          }
+        const hintedSandbox = await tryRestoreHintedSandbox();
+        if (hintedSandbox) {
+          return hintedSandbox;
         }
-        if (acquiredSandbox) {
-          try {
-            await upsertSkillsToSandbox(acquiredSandbox);
-            return assignSandbox(acquiredSandbox);
-          } catch (error) {
-            if (isSandboxUnavailableError(error)) {
-              return recoverUnavailableSandbox("id_hint");
-            }
-            return handleSetupFailure(error);
-          }
-        }
-        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 +8226,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,74 +8236,294 @@ 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;
+        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);
+          }
+        );
+      },
+      readFile: async (input) => await executeReadFile(input, {
+        toolCallId: "sandbox-read-file",
+        messages: []
+      }),
+      writeFile: async (input) => await executeWriteFile(input, {
+        toolCallId: "sandbox-write-file",
+        messages: []
+      })
+    };
+  };
+  const ensureReadySandbox = async () => {
+    const activeSandbox = await acquireSandbox();
+    await extendKeepAlive(activeSandbox);
+    return activeSandbox;
+  };
+  const loadToolExecutors = async (activeSandbox) => {
+    if (toolExecutors) {
+      return toolExecutors;
+    }
+    toolExecutors = await buildToolExecutors(activeSandbox);
+    return toolExecutors;
+  };
+  return {
+    configureSkills(skills) {
+      availableSkills = [...skills];
+    },
+    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",
+        {
+          "app.sandbox.stop.blocking": true
+        },
+        async () => {
+          await activeSandbox.stop({ blocking: true });
+        }
+      );
+      sandbox = null;
+      toolExecutors = void 0;
+    }
+  };
+}
+
+// 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 = [];
+  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 hostSkillPath = resolveHostSkillPath(availableSkills, filePath);
+      if (hostSkillPath) {
+        try {
+          const content = await fs4.readFile(hostSkillPath, "utf8");
+          setSpanAttributes({
+            "app.sandbox.path.length": filePath.length,
+            "app.sandbox.read.bytes": Buffer.byteLength(content, "utf8"),
+            "app.sandbox.read.chars": content.length,
+            "app.skill.virtual_read": true
+          });
+          setSpanStatus("ok");
+          return {
+            result: {
+              content,
+              path: filePath,
+              success: true
+            }
+          };
+        } catch (error) {
+          if (!isHostFileMissingError(error)) {
+            throw error;
+          }
+        }
+      }
+    }
+    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,
+          success: true
+        };
+      }
+    );
+    return { result };
+  };
+  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.writeFile",
+      "sandbox.fs.write",
+      {
+        "app.sandbox.path.length": filePath.length,
+        "app.sandbox.write.bytes": Buffer.byteLength(content, "utf8")
+      },
+      async () => {
         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
-          };
+          await executeWriteFile({ path: filePath, content });
         } 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);
-            }
-          }
-        }
-        if (restoreError && !commandError) {
-          throw restoreError;
+          throwSandboxOperationError("sandbox writeFile", error);
         }
-        return result;
-      },
-      readFile: async (input) => await executeReadFile(input, {
-        toolCallId: "sandbox-read-file",
-        messages: []
-      }),
-      writeFile: async (input) => await executeWriteFile(input, {
-        toolCallId: "sandbox-write-file",
-        messages: []
-      })
+        setSpanStatus("ok");
+      }
+    );
+    return {
+      result: {
+        ok: true,
+        path: filePath,
+        bytes_written: Buffer.byteLength(content, "utf8")
+      }
     };
-    return toolExecutors;
   };
   const execute = async (params) => {
     const rawInput = params.input ?? {};
@@ -8146,195 +8538,37 @@ function createSandboxExecutor(options) {
           return { result: custom.result };
         }
       }
-    }
-    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 {
-      }
-    }
-    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",
-        {
-          "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
-        }
-      };
+      return await executeBashTool(rawInput, bashCommand);
     }
     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 ?? "");
-          setSpanAttributes({
-            "app.sandbox.read.bytes": Buffer.byteLength(content, "utf8"),
-            "app.sandbox.read.chars": content.length
-          });
-          setSpanStatus("ok");
-          return {
-            content,
-            path: filePath,
-            success: true
-          };
-        }
-      );
-      return { result };
+      return await executeReadFileTool(rawInput);
     }
     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);
-          }
-        }
-      );
-      return {
-        result: {
-          ok: true,
-          path: filePath,
-          bytes_written: Buffer.byteLength(content, "utf8")
-        }
-      };
+      return await executeWriteFileTool(rawInput);
     }
     throw new Error(`unsupported sandbox tool: ${params.toolName}`);
   };
-  const dispose = async () => {
-    if (!sandbox) {
-      return;
-    }
-    await withSandboxSpan(
-      "sandbox.stop",
-      "sandbox.stop",
-      {
-        "app.sandbox.stop.blocking": true
-      },
-      async () => {
-        await sandbox.stop({ blocking: true });
-      }
-    );
-    sandbox = null;
-    toolExecutors = void 0;
-  };
   return {
     configureSkills(skills) {
       availableSkills = [...skills];
+      sessionManager.configureSkills(skills);
     },
     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();
+    }
   };
 }
 
@@ -9156,6 +9390,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 +9470,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 +9497,52 @@ 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();
+    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) {
@@ -9397,16 +9681,32 @@ async function generateAssistantReply(messageText, context = {}) {
     });
     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 +9903,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 +9955,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,7 +10559,7 @@ async function GET4(request, provider, waitUntil) {
 }
 
 // src/chat/slack/app-home.ts
-import fs4 from "fs";
+import fs5 from "fs";
 import path5 from "path";
 var DEFAULT_ABOUT_TEXT = "I help your team investigate, summarize, and act on work in Slack.";
 var MAX_HOME_SKILLS = 6;
@@ -10275,7 +10574,7 @@ function clampSectionText(text) {
 function loadAboutText() {
   const aboutPath = path5.join(homeDir(), "ABOUT.md");
   try {
-    const raw = fs4.readFileSync(aboutPath, "utf8").trim();
+    const raw = fs5.readFileSync(aboutPath, "utf8").trim();
     if (raw.length > 0) {
       return clampSectionText(raw);
     }
@@ -10625,7 +10924,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 +10932,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 +10973,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 +11100,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 +11135,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 +11160,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 +11185,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 +11208,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 +11803,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 +11989,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 +12036,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 +12060,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 +12073,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 +12086,9 @@ async function summarizeConversationImage(args, deps) {
   }
 }
 async function hydrateConversationVisionContextWithDeps(conversation, context, deps) {
+  if (!isVisionEnabled()) {
+    return;
+  }
   if (!context.channelId || !context.threadTs) {
     return;
   }
@@ -11766,6 +12289,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,
@@ -11945,13 +12469,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: message.id
           }
         );
         const progress = createProgressReporter({
@@ -12361,7 +12887,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 +12934,7 @@ function createSlackRuntime(options) {
   const replyToThread = createReplyToThread({
     getSlackAdapter: options.getSlackAdapter,
     prepareTurnState,
+    resolveUserAttachments: services.visionContext.resolveUserAttachments,
     services: services.replyExecutor
   });
   return createSlackTurnRuntime({