@sentry/junior 0.18.1 → 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,
@@ -2999,6 +2999,8 @@ function buildSystemPrompt(params) {
         "- If a loaded skill or `loadSkill` result declares `requires_capabilities`, run `jr-rpc issue-credential <capability> [--repo <owner/repo>]` as a bash command before authenticated bash/API work for that skill.",
         "- Use the minimum declared capability needed for the current operation.",
         "- If `jr-rpc issue-credential` returns `oauth_started`, relay its `message` to the user and stop. The runtime will resume after authorization.",
+        "- For disconnect + reconnect requests, run `jr-rpc delete-token <provider>` first, then `jr-rpc issue-credential` \u2014 the system handles the reconnect without auto-resuming the reconnect message.",
+        "- Use `jr-rpc oauth-start <provider>` only when the user explicitly asks to connect a provider and there is no task to resume after authorization.",
         "- GitHub capabilities need repository context, which can come from `--repo` or a configured `github.repo` default.",
         "- To persist or read conversation defaults (for example `github.repo`), run `jr-rpc config get|set|unset|list ...` as a bash command.",
         "- Capabilities are provider-qualified (for example `github.issues.write`).",
@@ -3539,6 +3541,52 @@ async function handleIssueCredentialCommand(args, deps) {
     });
   } catch (error) {
     if (error instanceof CredentialUnavailableError && getPluginOAuthConfig(error.provider) && deps.requesterId) {
+      const authAction = deps.providerAuthActions?.get(error.provider);
+      if (authAction?.kind === "oauth_started") {
+        const providerLabel = formatProviderLabel(error.provider);
+        return commandResult({
+          stdout: {
+            credential_unavailable: true,
+            oauth_started: true,
+            provider: error.provider,
+            private_delivery_sent: authAction.delivered,
+            message: authAction.delivered ? `I've already sent you a private authorization link to connect your ${providerLabel} account. Finish that flow, then return to Slack.` : `I still need to connect your ${providerLabel} account, but I wasn't able to send you a private authorization link. Please send me a direct message and try again.`
+          },
+          exitCode: 0
+        });
+      }
+      if (authAction?.kind === "token_deleted") {
+        const reconnectResult = await startOAuthFlow(error.provider, {
+          requesterId: deps.requesterId,
+          channelId: deps.channelId,
+          threadTs: deps.threadTs,
+          activeSkillName: deps.activeSkill?.name ?? void 0
+          // Intentionally no userMessage — reconnect flows must not auto-resume.
+        });
+        if (!reconnectResult.ok) {
+          return commandResult({
+            stderr: `${reconnectResult.error}
+`,
+            exitCode: 1
+          });
+        }
+        const delivered = !!reconnectResult.delivery;
+        deps.providerAuthActions?.set(error.provider, {
+          kind: "oauth_started",
+          delivered
+        });
+        const providerLabel = formatProviderLabel(error.provider);
+        return commandResult({
+          stdout: {
+            credential_unavailable: true,
+            oauth_started: true,
+            provider: error.provider,
+            private_delivery_sent: delivered,
+            message: delivered ? `I need to connect your ${providerLabel} account first. I've sent you a private authorization link.` : `I need to connect your ${providerLabel} account first, but I wasn't able to send you a private authorization link. Please send me a direct message and try your command again.`
+          },
+          exitCode: 0
+        });
+      }
       const oauthResult = await startOAuthFlow(error.provider, {
         requesterId: deps.requesterId,
         channelId: deps.channelId,
@@ -3808,6 +3856,10 @@ async function handleOAuthStartCommand(args, deps) {
     return commandResult({ stderr: `${result.error}
 `, exitCode: 1 });
   }
+  deps.providerAuthActions?.set(provider, {
+    kind: "oauth_started",
+    delivered: !!result.delivery
+  });
   if (!result.delivery) {
     return commandResult({
       stdout: {
@@ -3854,6 +3906,7 @@ async function handleDeleteTokenCommand(args, deps) {
     });
   }
   await unlinkProvider(deps.requesterId, provider, deps.userTokenStore);
+  deps.providerAuthActions?.set(provider, { kind: "token_deleted" });
   logInfo(
     "jr_rpc_delete_token",
     {},
@@ -4968,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 } : {},
@@ -4976,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
@@ -4989,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,
@@ -5001,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({
@@ -5014,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);
@@ -6754,103 +6803,50 @@ function createToolState(hooks, context) {
     }
   };
 }
-function wrapToolExecution(toolName, toolDef, hooks) {
-  const maybeExecutable = toolDef;
-  if (!maybeExecutable.execute) {
-    return toolDef;
-  }
-  const originalExecute = maybeExecutable.execute.bind(toolDef);
-  maybeExecutable.execute = async (...args) => {
-    const input = args[0];
-    await hooks.onToolCallStart?.(toolName, input);
-    return originalExecute(...args);
-  };
-  return toolDef;
-}
 function createTools(availableSkills, hooks = {}, context) {
   const state = createToolState(hooks, context);
   const tools = {
-    loadSkill: wrapToolExecution(
-      "loadSkill",
-      createLoadSkillTool(context.sandbox, availableSkills, {
-        onSkillLoaded: hooks.onSkillLoaded
-      }),
-      hooks
-    ),
-    systemTime: wrapToolExecution("systemTime", createSystemTimeTool(), hooks),
-    bash: wrapToolExecution("bash", createBashTool(), hooks),
-    attachFile: wrapToolExecution(
-      "attachFile",
-      createAttachFileTool(context.sandbox, hooks),
-      hooks
-    ),
-    readFile: wrapToolExecution("readFile", createReadFileTool(), hooks),
-    writeFile: wrapToolExecution("writeFile", createWriteFileTool(), hooks),
-    webSearch: wrapToolExecution("webSearch", createWebSearchTool(), hooks),
-    webFetch: wrapToolExecution("webFetch", createWebFetchTool(hooks), hooks),
-    imageGenerate: wrapToolExecution(
-      "imageGenerate",
-      createImageGenerateTool(hooks, hooks.toolOverrides?.imageGenerate),
-      hooks
-    ),
-    slackCanvasUpdate: wrapToolExecution(
-      "slackCanvasUpdate",
-      createSlackCanvasUpdateTool(state, context),
-      hooks
-    ),
-    slackListCreate: wrapToolExecution(
-      "slackListCreate",
-      createSlackListCreateTool(state),
-      hooks
-    ),
-    slackListAddItems: wrapToolExecution(
-      "slackListAddItems",
-      createSlackListAddItemsTool(state),
-      hooks
-    ),
-    slackListGetItems: wrapToolExecution(
-      "slackListGetItems",
-      createSlackListGetItemsTool(state),
-      hooks
+    loadSkill: createLoadSkillTool(availableSkills, {
+      onSkillLoaded: hooks.onSkillLoaded
+    }),
+    systemTime: createSystemTimeTool(),
+    bash: createBashTool(),
+    attachFile: createAttachFileTool(context.sandbox, hooks),
+    readFile: createReadFileTool(),
+    writeFile: createWriteFileTool(),
+    webSearch: createWebSearchTool(),
+    webFetch: createWebFetchTool(hooks),
+    imageGenerate: createImageGenerateTool(
+      hooks,
+      hooks.toolOverrides?.imageGenerate
     ),
-    slackListUpdateItem: wrapToolExecution(
-      "slackListUpdateItem",
-      createSlackListUpdateItemTool(state),
-      hooks
-    )
+    slackCanvasUpdate: createSlackCanvasUpdateTool(state, context),
+    slackListCreate: createSlackListCreateTool(state),
+    slackListAddItems: createSlackListAddItemsTool(state),
+    slackListGetItems: createSlackListGetItemsTool(state),
+    slackListUpdateItem: createSlackListUpdateItemTool(state)
   };
   if (context.mcpToolManager && context.getActiveSkills) {
-    tools.searchTools = wrapToolExecution(
-      "searchTools",
-      createSearchToolsTool(context.mcpToolManager, context.getActiveSkills),
-      hooks
+    tools.searchTools = createSearchToolsTool(
+      context.mcpToolManager,
+      context.getActiveSkills
     );
   }
   const { channelCapabilities } = context;
   if (channelCapabilities.canCreateCanvas) {
-    tools.slackCanvasCreate = wrapToolExecution(
-      "slackCanvasCreate",
-      createSlackCanvasCreateTool(context, state),
-      hooks
-    );
+    tools.slackCanvasCreate = createSlackCanvasCreateTool(context, state);
   }
   if (channelCapabilities.canPostToChannel) {
-    tools.slackChannelPostMessage = wrapToolExecution(
-      "slackChannelPostMessage",
-      createSlackChannelPostMessageTool(context, state),
-      hooks
-    );
-    tools.slackChannelListMessages = wrapToolExecution(
-      "slackChannelListMessages",
-      createSlackChannelListMessagesTool(context),
-      hooks
+    tools.slackChannelPostMessage = createSlackChannelPostMessageTool(
+      context,
+      state
     );
+    tools.slackChannelListMessages = createSlackChannelListMessagesTool(context);
   }
   if (channelCapabilities.canAddReactions) {
-    tools.slackMessageAddReaction = wrapToolExecution(
-      "slackMessageAddReaction",
-      createSlackMessageAddReactionTool(context, state),
-      hooks
+    tools.slackMessageAddReaction = createSlackMessageAddReactionTool(
+      context,
+      state
     );
   }
   return tools;
@@ -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,14 +6966,7 @@ function extractHttpErrorDetails(error, options = {}) {
   };
 }
 
-// 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;
+// src/chat/sandbox/errors.ts
 var SANDBOX_ERROR_FIELDS = [
   {
     sourceKey: "sandboxId",
@@ -6988,140 +6974,410 @@ var SANDBOX_ERROR_FIELDS = [
     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 getSandboxErrorDetails(error) {
+  return extractHttpErrorDetails(error, {
+    attributePrefix: "app.sandbox.api_error",
+    extraFields: [...SANDBOX_ERROR_FIELDS]
+  });
 }
-function truncateOutput(output, maxLength) {
-  if (output.length <= maxLength) {
-    return { value: output, truncated: false };
+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;
   }
-  const truncatedLength = output.length - maxLength;
-  return {
-    value: `${output.slice(0, maxLength)}
-
-[output truncated: ${truncatedLength} characters removed]`,
-    truncated: true
-  };
-}
-function toPosixRelative(base, absolute) {
-  return path4.relative(base, absolute).split(path4.sep).join("/");
+  return false;
 }
-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);
+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 files;
+  return void 0;
 }
-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)
+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
       });
     }
-    index.skills.push({
-      name: skill.name,
-      description: skill.description,
-      root: sandboxSkillDir(skill.name)
-    });
+  } catch {
   }
-  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")
-    });
+  let causeMessage;
+  try {
+    causeMessage = getFirstErrorMessage(error);
+  } catch (cause) {
+    causeMessage = cause instanceof Error ? cause.message : void 0;
   }
-  return filesToWrite;
+  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
+    }
+  );
 }
-function buildEvalGitHubCliStub() {
-  return `#!/usr/bin/env node
-const fs = require("node:fs");
-const path = require("node:path");
-const { spawnSync } = require("node:child_process");
 
-const args = process.argv.slice(2);
-const statePath = "/vercel/sandbox/.junior/eval-gh-state.json";
-const fallbackBinaries = ["/usr/bin/gh", "/usr/local/bin/gh", "/bin/gh"];
-const flagsWithValues = new Set([
-  "--repo",
-  "--title",
-  "--body",
-  "--body-file",
-  "--json",
-  "--search",
-  "--state",
-  "--limit",
-  "--method",
-  "--jq",
-  "--template",
-  "--hostname",
-]);
+// src/chat/sandbox/session.ts
+import { Sandbox } from "@vercel/sandbox";
+import { createBashTool as createBashTool2 } from "bash-tool";
 
-function getFlag(name) {
-  for (let index = 0; index < args.length; index += 1) {
-    const value = args[index];
-    if (value === name) {
-      return args[index + 1];
-    }
-    if (value.startsWith(name + "=")) {
-      return value.slice(name.length + 1);
-    }
+// src/chat/runtime/status-format.ts
+var SLACK_STATUS_MAX_LENGTH = 50;
+function truncateWithEllipsis(text, maxLength) {
+  if (text.length <= maxLength) {
+    return text;
   }
-  return undefined;
+  return `${text.slice(0, Math.max(1, maxLength - 3)).trimEnd()}...`;
 }
-
-function getPositionals() {
-  const values = [];
-  for (let index = 0; index < args.length; index += 1) {
-    const value = args[index];
-    if (flagsWithValues.has(value)) {
-      index += 1;
+function truncateStatusText(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return "";
+  }
+  return truncateWithEllipsis(trimmed, SLACK_STATUS_MAX_LENGTH);
+}
+function compactStatusPath(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  if (trimmed.length <= 80) {
+    return trimmed;
+  }
+  return `...${trimmed.slice(-77)}`;
+}
+function compactStatusText(value, maxLength = 80) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  return truncateWithEllipsis(trimmed, maxLength);
+}
+function readShellToken(command, startIndex) {
+  let index = startIndex;
+  while (index < command.length && /\s/.test(command[index] ?? "")) {
+    index += 1;
+  }
+  if (index >= command.length) {
+    return void 0;
+  }
+  let token = "";
+  let quote;
+  while (index < command.length) {
+    const char = command[index];
+    if (!char) {
+      break;
+    }
+    if (quote) {
+      if (char === quote) {
+        quote = void 0;
+        index += 1;
+        continue;
+      }
+      if (char === "\\" && quote === '"' && index + 1 < command.length) {
+        token += command[index + 1];
+        index += 2;
+        continue;
+      }
+      token += char;
+      index += 1;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      break;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      index += 1;
+      continue;
+    }
+    if (char === "\\" && index + 1 < command.length) {
+      token += command[index + 1];
+      index += 2;
+      continue;
+    }
+    token += char;
+    index += 1;
+  }
+  return { token, nextIndex: index };
+}
+function compactStatusCommand(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  let index = 0;
+  while (index < trimmed.length) {
+    const parsed = readShellToken(trimmed, index);
+    if (!parsed) {
+      return void 0;
+    }
+    index = parsed.nextIndex;
+    if (!parsed.token) {
+      continue;
+    }
+    if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(parsed.token)) {
+      continue;
+    }
+    const normalized = parsed.token.replace(/[\\/]+$/g, "");
+    if (!normalized) {
+      return void 0;
+    }
+    const parts = normalized.split(/[\\/]/).filter((part) => part.length > 0);
+    const command = parts.length > 0 ? parts[parts.length - 1] : normalized;
+    return compactStatusText(command, 40);
+  }
+  return void 0;
+}
+function compactStatusFilename(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim().replace(/[\\/]+$/g, "");
+  if (!trimmed) {
+    return void 0;
+  }
+  const parts = trimmed.split(/[\\/]/).filter((part) => part.length > 0);
+  const filename = parts.length > 0 ? parts[parts.length - 1] : trimmed;
+  return compactStatusText(filename, 80);
+}
+function extractStatusUrlDomain(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  try {
+    const parsed = new URL(trimmed);
+    return parsed.hostname || void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/chat/runtime/assistant-status.ts
+var STATUS_PATTERNS = {
+  thinking: {
+    defaultContext: "\u2026",
+    variants: ["Thinking", "Reasoning", "Considering", "Working through"]
+  },
+  searching: {
+    defaultContext: "sources",
+    variants: ["Searching", "Scanning", "Probing", "Trawling"]
+  },
+  reading: {
+    defaultContext: "task",
+    variants: ["Reading", "Inspecting", "Parsing", "Skimming"]
+  },
+  reviewing: {
+    defaultContext: "results",
+    variants: ["Reviewing", "Checking", "Inspecting", "Auditing"]
+  },
+  loading: {
+    defaultContext: "task",
+    variants: ["Loading", "Priming", "Booting", "Spinning up"]
+  },
+  updating: {
+    defaultContext: "state",
+    variants: ["Updating", "Patching", "Refreshing", "Adjusting"]
+  },
+  fetching: {
+    defaultContext: "sources",
+    variants: ["Fetching", "Pulling", "Retrieving", "Loading"]
+  },
+  creating: {
+    defaultContext: "draft",
+    variants: ["Creating", "Building", "Assembling", "Generating"]
+  },
+  listing: {
+    defaultContext: "items",
+    variants: ["Listing", "Gathering", "Collecting", "Enumerating"]
+  },
+  posting: {
+    defaultContext: "reply",
+    variants: ["Posting", "Sending", "Delivering", "Dispatching"]
+  },
+  adding: {
+    defaultContext: "details",
+    variants: ["Adding", "Applying", "Attaching", "Dropping in"]
+  },
+  running: {
+    defaultContext: "tasks",
+    variants: ["Running", "Executing", "Launching", "Processing"]
+  }
+};
+function makeAssistantStatus(kind, context) {
+  return { kind, ...context ? { context } : {} };
+}
+function normalizeAssistantStatusText(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return "";
+  }
+  return truncateStatusText(trimmed.replace(/(?:\.\s*)+$/, "").trim());
+}
+function buildAssistantStatusPresentation(args) {
+  const random = args.random ?? Math.random;
+  const pattern = STATUS_PATTERNS[args.status.kind];
+  const context = normalizeAssistantStatusText(args.status.context ?? "") || pattern.defaultContext;
+  const index = Math.floor(random() * pattern.variants.length);
+  const verb = pattern.variants[index] ?? pattern.variants[0];
+  const visible = truncateStatusText(`${verb} ${context}`);
+  const hint = truncateStatusText(`${pattern.variants[0]} ${context}`);
+  return {
+    key: `${args.status.kind}:${context}`,
+    hint,
+    visible,
+    suggestions: Array.from(/* @__PURE__ */ new Set([visible, hint]))
+  };
+}
+function createSlackAdapterAssistantStatusTransport(args) {
+  return {
+    async setStatus(channelId, threadTs, status, suggestions) {
+      try {
+        await args.getSlackAdapter().setAssistantStatus(channelId, threadTs, status, suggestions);
+      } catch (error) {
+        logAssistantStatusFailure(status, error);
+      }
+    }
+  };
+}
+function createSlackWebApiAssistantStatusTransport(args) {
+  const getClient2 = args?.getSlackClient ?? getSlackClient;
+  return {
+    async setStatus(channelId, threadTs, status, suggestions) {
+      try {
+        await getClient2().assistant.threads.setStatus({
+          channel_id: channelId,
+          thread_ts: threadTs,
+          status,
+          ...suggestions ? { loading_messages: suggestions } : {}
+        });
+      } catch (error) {
+        logAssistantStatusFailure(status, error);
+      }
+    }
+  };
+}
+function logAssistantStatusFailure(status, error) {
+  logWarn(
+    "assistant_status_update_failed",
+    {},
+    {
+      "app.slack.status_text": status || "(clear)",
+      "error.message": error instanceof Error ? error.message : String(error)
+    },
+    "Failed to update assistant status"
+  );
+}
+
+// src/chat/sandbox/skill-sync.ts
+import fs3 from "fs/promises";
+import path4 from "path";
+
+// src/chat/sandbox/eval-gh-stub.ts
+function buildEvalGitHubCliStub() {
+  return `#!/usr/bin/env node
+const fs = require("node:fs");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+const args = process.argv.slice(2);
+const statePath = "/vercel/sandbox/.junior/eval-gh-state.json";
+const fallbackBinaries = ["/usr/bin/gh", "/usr/local/bin/gh", "/bin/gh"];
+const flagsWithValues = new Set([
+  "--repo",
+  "--title",
+  "--body",
+  "--body-file",
+  "--json",
+  "--search",
+  "--state",
+  "--limit",
+  "--method",
+  "--jq",
+  "--template",
+  "--hostname",
+]);
+
+function getFlag(name) {
+  for (let index = 0; index < args.length; index += 1) {
+    const value = args[index];
+    if (value === name) {
+      return args[index + 1];
+    }
+    if (value.startsWith(name + "=")) {
+      return value.slice(name.length + 1);
+    }
+  }
+  return undefined;
+}
+
+function getPositionals() {
+  const values = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const value = args[index];
+    if (flagsWithValues.has(value)) {
+      index += 1;
       continue;
     }
     if (value.startsWith("--") && value.includes("=")) {
@@ -7256,6 +7512,8 @@ if (args[0] === "api") {
     outputJson({ items: [] });
     process.exit(0);
   }
+  outputJson({});
+  process.exit(0);
 }
 
 if (args[0] === "issue") {
@@ -7297,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");
@@ -7338,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]
-  });
+  return files;
 }
-function sleep2(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
+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)
+    });
+  }
+  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 isAlreadyExistsError(error) {
-  const details = getSandboxErrorDetails(error);
-  return details.searchableText.includes("already exists") || details.searchableText.includes("file exists") || details.searchableText.includes("eexist");
+function collectDirectories(filesToWrite, workspaceRoot) {
+  const directoriesToEnsure = /* @__PURE__ */ new Set();
+  for (const file of filesToWrite) {
+    const normalizedPath = 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);
+    }
+  }
+  return Array.from(directoriesToEnsure).filter(
+    (directory) => directory === workspaceRoot || directory.startsWith(`${workspaceRoot}/`)
+  ).sort((a, b) => a.length - b.length);
 }
-function findInErrorChain(error, predicate) {
-  const seen = /* @__PURE__ */ new Set();
-  let current = error;
-  while (current && !seen.has(current)) {
-    if (predicate(current)) {
-      return true;
+function resolveHostSkillPath(availableSkills, sandboxPath) {
+  const normalizedPath = path4.posix.normalize(sandboxPath.trim());
+  for (const skill of availableSkills) {
+    const virtualRoot = sandboxSkillDir(skill.name);
+    if (normalizedPath !== virtualRoot && !normalizedPath.startsWith(`${virtualRoot}/`)) {
+      continue;
     }
-    seen.add(current);
-    if (typeof current === "object") {
-      current = current.cause;
-    } else {
-      current = void 0;
+    const relativePath = 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;
   }
-  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");
-  });
+  return null;
 }
-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 isHostFileMissingError(error) {
+  return Boolean(
+    error && typeof error === "object" && error.code === "ENOENT"
+  );
 }
-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;
-      }
+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);
+          }
+        }
+      );
     }
-    seen.add(current);
-    current = typeof current === "object" ? current.cause : void 0;
-  }
-  return void 0;
+  );
 }
-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;
+
+// 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?.("Booting up...");
-        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",
@@ -7502,277 +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
-          },
-          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);
-            }
-          }
-        );
+  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
+          },
+          ...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) => {
-            if (!emitStatus || statusCount >= 4 || sentStatuses.has(status)) {
-              return;
-            }
-            sentStatuses.add(status);
-            statusCount += 1;
-            await emitStatus(status);
-          };
-          const reportSnapshotPhase = async (phase) => {
-            if (phase === "resolve_start") {
-              await emitSandboxStatus("Checking sandbox snapshot cache...");
-              return;
-            }
-            if (phase === "waiting_for_lock") {
-              await emitSandboxStatus("Waiting for sandbox snapshot build...");
-              return;
-            }
-            if (phase === "building_snapshot") {
-              await emitSandboxStatus("Building sandbox snapshot...");
-              return;
-            }
-            if (phase === "cache_hit") {
-              await emitSandboxStatus("Using cached 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("Preparing 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("Booting up...");
-                  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;
+        discardHintIfProfileChanged();
+        const cachedSandbox = await tryReuseCachedSandbox();
+        if (cachedSandbox) {
+          return cachedSandbox;
         }
-        const recoverUnavailableSandbox = async (source) => {
-          setSpanAttributes({
-            "app.sandbox.recovery.attempted": true,
-            "app.sandbox.recovery.source": source
-          });
-          sandbox = null;
-          sandboxIdHint = void 0;
-          toolExecutors = void 0;
-          const replacement = await createFreshSandbox();
-          setSpanAttributes({
-            "app.sandbox.recovery.succeeded": true
-          });
-          return replacement;
-        };
-        if (sandbox) {
-          const cachedSandbox = sandbox;
-          try {
-            await withSandboxSpan(
-              "sandbox.reuse_cached",
-              "sandbox.acquire.cached",
-              {
-                "app.sandbox.reused": true,
-                "app.sandbox.source": "memory"
-              },
-              async () => {
-                await upsertSkillsToSandbox(cachedSandbox);
-              }
-            );
-            return cachedSandbox;
-          } catch (error) {
-            if (isSandboxUnavailableError(error)) {
-              return recoverUnavailableSandbox("memory");
-            }
-            return handleSetupFailure(error);
-          }
+        const hintedSandbox = await tryRestoreHintedSandbox();
+        if (hintedSandbox) {
+          return hintedSandbox;
         }
-        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;
-          }
-        }
-        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",
@@ -7780,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
       })
     );
@@ -7790,63 +8236,24 @@ function createSandboxExecutor(options) {
     if (!executeReadFile || !executeWriteFile) {
       throw new Error("bash-tool did not return executable tool handlers");
     }
-    toolExecutors = {
+    return {
       bash: async (input) => {
-        const restoreNetworkPolicy = activeSandbox.networkPolicy ?? "allow-all";
-        const headerTransforms = input.headerTransforms;
-        if (headerTransforms && headerTransforms.length > 0) {
-          const policy = mergeNetworkPolicyWithHeaderTransforms(
-            restoreNetworkPolicy,
-            headerTransforms
-          );
-          await activeSandbox.updateNetworkPolicy(policy);
-        }
         const script = buildNonInteractiveShellScript(input.command, {
           env: input.env,
           pathPrefix: `${SANDBOX_RUNTIME_BIN_DIR}:$PATH`
         });
-        let commandError;
-        let result;
-        let restoreError;
-        try {
-          const commandResult2 = await activeSandbox.runCommand({
-            cmd: "bash",
-            args: ["-c", script],
-            cwd: SANDBOX_WORKSPACE_ROOT
-          });
-          const maxOutputLength = Number.parseInt(
-            process.env.SANDBOX_BASH_MAX_OUTPUT_CHARS ?? "",
-            10
-          );
-          const boundedOutputLength = Number.isFinite(maxOutputLength) && maxOutputLength > 0 ? maxOutputLength : DEFAULT_MAX_OUTPUT_LENGTH;
-          const stdoutRaw = await commandResult2.stdout();
-          const stderrRaw = await commandResult2.stderr();
-          const stdout = truncateOutput(stdoutRaw, boundedOutputLength);
-          const stderr = truncateOutput(stderrRaw, boundedOutputLength);
-          result = {
-            stdout: stdout.value,
-            stderr: stderr.value,
-            exitCode: commandResult2.exitCode,
-            stdoutTruncated: stdout.truncated,
-            stderrTruncated: stderr.truncated
-          };
-        } catch (error) {
-          commandError = error;
-          throw error;
-        } finally {
-          if (headerTransforms && headerTransforms.length > 0) {
-            try {
-              await activeSandbox.updateNetworkPolicy(restoreNetworkPolicy);
-            } catch (error) {
-              restoreError = error;
-              await invalidateSandboxInstance(activeSandbox, error);
-            }
+        return await withTemporaryHeaderTransforms(
+          sandboxInstance,
+          input.headerTransforms,
+          async () => {
+            const commandResult2 = await sandboxInstance.runCommand({
+              cmd: "bash",
+              args: ["-c", script],
+              cwd: SANDBOX_WORKSPACE_ROOT
+            });
+            return await readCommandOutput(commandResult2);
           }
-        }
-        if (restoreError && !commandError) {
-          throw restoreError;
-        }
-        return result;
+        );
       },
       readFile: async (input) => await executeReadFile(input, {
         toolCallId: "sandbox-read-file",
@@ -7857,191 +8264,18 @@ function createSandboxExecutor(options) {
         messages: []
       })
     };
-    return toolExecutors;
   };
-  const execute = async (params) => {
-    const rawInput = params.input ?? {};
-    const bashCommand = params.toolName === "bash" ? String(rawInput.command ?? "").trim() : void 0;
-    if (params.toolName === "bash") {
-      if (!bashCommand) {
-        throw new Error("command is required");
-      }
-      if (options?.runBashCustomCommand) {
-        const custom = await options.runBashCustomCommand(bashCommand);
-        if (custom.handled) {
-          return { result: custom.result };
-        }
-      }
-    }
+  const ensureReadySandbox = async () => {
     const activeSandbox = await acquireSandbox();
-    const keepAliveMs = Number.parseInt(
-      process.env.VERCEL_SANDBOX_KEEPALIVE_MS ?? "0",
-      10
-    );
-    if (Number.isFinite(keepAliveMs) && keepAliveMs > 0) {
-      try {
-        await withSandboxSpan(
-          "sandbox.keepalive.extend",
-          "sandbox.keepalive",
-          {
-            "app.sandbox.keepalive_ms": keepAliveMs
-          },
-          async () => {
-            await activeSandbox.extendTimeout(keepAliveMs);
-          }
-        );
-      } catch {
-      }
-    }
-    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
-        }
-      };
-    }
-    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 };
-    }
-    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")
-        }
-      };
-    }
-    throw new Error(`unsupported sandbox tool: ${params.toolName}`);
+    await extendKeepAlive(activeSandbox);
+    return activeSandbox;
   };
-  const dispose = async () => {
-    if (!sandbox) {
-      return;
+  const loadToolExecutors = async (activeSandbox) => {
+    if (toolExecutors) {
+      return toolExecutors;
     }
-    await withSandboxSpan(
-      "sandbox.stop",
-      "sandbox.stop",
-      {
-        "app.sandbox.stop.blocking": true
-      },
-      async () => {
-        await sandbox.stop({ blocking: true });
-      }
-    );
-    sandbox = null;
-    toolExecutors = void 0;
+    toolExecutors = await buildToolExecutors(activeSandbox);
+    return toolExecutors;
   };
   return {
     configureSkills(skills) {
@@ -8053,199 +8287,298 @@ function createSandboxExecutor(options) {
     getDependencyProfileHash() {
       return dependencyProfileHash;
     },
-    canExecute(toolName) {
-      return SANDBOX_TOOL_NAMES.has(toolName);
-    },
     async createSandbox() {
       return await acquireSandbox();
     },
-    execute,
-    dispose
+    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/runtime/dev-agent-trace.ts
-function shouldEmitDevAgentTrace() {
-  return process.env.NODE_ENV === "development";
-}
-
-// src/chat/runtime/status-format.ts
-var SLACK_STATUS_MAX_LENGTH = 50;
-function truncateWithEllipsis(text, maxLength) {
-  if (text.length <= maxLength) {
-    return text;
-  }
-  return `${text.slice(0, Math.max(1, maxLength - 3)).trimEnd()}...`;
-}
-function truncateStatusText(text) {
-  const trimmed = text.trim();
-  if (!trimmed) {
-    return "";
-  }
-  return truncateWithEllipsis(trimmed, SLACK_STATUS_MAX_LENGTH);
-}
-function compactStatusPath(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim();
-  if (!trimmed) {
+// 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;
   }
-  if (trimmed.length <= 80) {
-    return trimmed;
-  }
-  return `...${trimmed.slice(-77)}`;
+  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 compactStatusText(value, maxLength = 80) {
-  if (typeof value !== "string") {
+function parseEnv(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
     return void 0;
   }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return void 0;
-  }
-  return truncateWithEllipsis(trimmed, maxLength);
+  return Object.fromEntries(
+    Object.entries(raw).filter(([, value]) => typeof value === "string").map(([key, value]) => [key, value])
+  );
 }
-function readShellToken(command, startIndex) {
-  let index = startIndex;
-  while (index < command.length && /\s/.test(command[index] ?? "")) {
-    index += 1;
-  }
-  if (index >= command.length) {
-    return void 0;
-  }
-  let token = "";
-  let quote;
-  while (index < command.length) {
-    const char = command[index];
-    if (!char) {
-      break;
+function createSandboxWorkspace(sandbox) {
+  return {
+    sandboxId: sandbox.sandboxId,
+    readFileToBuffer(input) {
+      return sandbox.readFileToBuffer(input);
+    },
+    runCommand(input) {
+      return sandbox.runCommand(input);
     }
-    if (quote) {
-      if (char === quote) {
-        quote = void 0;
-        index += 1;
-        continue;
+  };
+}
+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;
+        }
       }
-      if (char === "\\" && quote === '"' && index + 1 < command.length) {
-        token += command[index + 1];
-        index += 2;
-        continue;
+    );
+    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 {
+          await executeWriteFile({ path: filePath, content });
+        } catch (error) {
+          throwSandboxOperationError("sandbox writeFile", error);
+        }
+        setSpanStatus("ok");
+      }
+    );
+    return {
+      result: {
+        ok: true,
+        path: filePath,
+        bytes_written: Buffer.byteLength(content, "utf8")
+      }
+    };
+  };
+  const execute = async (params) => {
+    const rawInput = params.input ?? {};
+    const bashCommand = params.toolName === "bash" ? String(rawInput.command ?? "").trim() : void 0;
+    if (params.toolName === "bash") {
+      if (!bashCommand) {
+        throw new Error("command is required");
+      }
+      if (options?.runBashCustomCommand) {
+        const custom = await options.runBashCustomCommand(bashCommand);
+        if (custom.handled) {
+          return { result: custom.result };
+        }
       }
-      token += char;
-      index += 1;
-      continue;
-    }
-    if (/\s/.test(char)) {
-      break;
-    }
-    if (char === '"' || char === "'") {
-      quote = char;
-      index += 1;
-      continue;
-    }
-    if (char === "\\" && index + 1 < command.length) {
-      token += command[index + 1];
-      index += 2;
-      continue;
-    }
-    token += char;
-    index += 1;
-  }
-  return { token, nextIndex: index };
-}
-function compactStatusCommand(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return void 0;
-  }
-  let index = 0;
-  while (index < trimmed.length) {
-    const parsed = readShellToken(trimmed, index);
-    if (!parsed) {
-      return void 0;
+      return await executeBashTool(rawInput, bashCommand);
     }
-    index = parsed.nextIndex;
-    if (!parsed.token) {
-      continue;
+    if (params.toolName === "readFile") {
+      return await executeReadFileTool(rawInput);
     }
-    if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(parsed.token)) {
-      continue;
+    if (params.toolName === "writeFile") {
+      return await executeWriteFileTool(rawInput);
     }
-    const normalized = parsed.token.replace(/[\\/]+$/g, "");
-    if (!normalized) {
-      return void 0;
+    throw new Error(`unsupported sandbox tool: ${params.toolName}`);
+  };
+  return {
+    configureSkills(skills) {
+      availableSkills = [...skills];
+      sessionManager.configureSkills(skills);
+    },
+    getSandboxId() {
+      return sessionManager.getSandboxId();
+    },
+    getDependencyProfileHash() {
+      return sessionManager.getDependencyProfileHash();
+    },
+    canExecute(toolName) {
+      return SANDBOX_TOOL_NAMES.has(toolName);
+    },
+    async createSandbox() {
+      return createSandboxWorkspace(await sessionManager.createSandbox());
+    },
+    execute,
+    async dispose() {
+      await sessionManager.dispose();
     }
-    const parts = normalized.split(/[\\/]/).filter((part) => part.length > 0);
-    const command = parts.length > 0 ? parts[parts.length - 1] : normalized;
-    return compactStatusText(command, 40);
-  }
-  return void 0;
-}
-function compactStatusFilename(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim().replace(/[\\/]+$/g, "");
-  if (!trimmed) {
-    return void 0;
-  }
-  const parts = trimmed.split(/[\\/]/).filter((part) => part.length > 0);
-  const filename = parts.length > 0 ? parts[parts.length - 1] : trimmed;
-  return compactStatusText(filename, 80);
+  };
 }
-function extractStatusUrlDomain(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return void 0;
-  }
-  try {
-    const parsed = new URL(trimmed);
-    return parsed.hostname || void 0;
-  } catch {
-    return void 0;
-  }
+
+// src/chat/runtime/dev-agent-trace.ts
+function shouldEmitDevAgentTrace() {
+  return process.env.NODE_ENV === "development";
 }
 
 // src/chat/runtime/tool-status.ts
-function formatToolStatus(toolName) {
-  const known = {
-    loadSkill: "Loading skill instructions",
-    systemTime: "Reading current system time",
-    bash: "Working in the shell",
-    readFile: "Reading a file",
-    writeFile: "Updating a file",
-    webSearch: "Searching public sources",
-    webFetch: "Reading source pages",
-    slackChannelPostMessage: "Posting message to channel",
-    slackMessageAddReaction: "Adding emoji reaction",
-    slackChannelListMessages: "Listing channel messages",
-    slackCanvasCreate: "Creating detailed brief",
-    slackCanvasUpdate: "Updating detailed brief",
-    slackListCreate: "Creating tracking list",
-    slackListAddItems: "Updating tracking list",
-    slackListUpdateItem: "Updating tracking list",
-    imageGenerate: "Generating image",
-    searchTools: "Searching active tools"
-  };
-  if (known[toolName]) {
-    return known[toolName];
-  }
-  const mcpMatch = /^mcp__([^_]+)__(.+)$/.exec(toolName);
-  if (mcpMatch) {
-    return `Running ${mcpMatch[1]}/${mcpMatch[2]}`;
-  }
-  const readable = toolName.replaceAll("_", " ").trim();
-  return readable.length > 0 ? `Running ${readable}` : "Running tool";
-}
-function formatToolStatusWithInput(toolName, input) {
+function buildToolStatus(toolName, input) {
   const obj = input && typeof input === "object" ? input : void 0;
   const command = obj ? compactStatusCommand(obj.command) : void 0;
   const path6 = obj ? compactStatusPath(obj.path) : void 0;
@@ -8255,33 +8588,63 @@ function formatToolStatusWithInput(toolName, input) {
   const skillName = obj ? compactStatusText(obj.skill_name ?? obj.skillName, 40) : void 0;
   const provider = obj ? compactStatusText(obj.provider, 20) : void 0;
   if (command && toolName === "bash") {
-    return `Running ${command}`;
+    return makeAssistantStatus("running", command);
   }
   if (filename && toolName === "readFile") {
-    return `Reading file ${filename}`;
+    return makeAssistantStatus("reading", filename);
   }
   if (filename && toolName === "writeFile") {
-    return `Updating file ${filename}`;
+    return makeAssistantStatus("updating", filename);
   }
   if (path6 && toolName === "writeFile") {
-    return `Updating file ${path6}`;
+    return makeAssistantStatus("updating", path6);
   }
   if (skillName && toolName === "loadSkill") {
-    return `Loading skill ${skillName}`;
+    return makeAssistantStatus("loading", skillName);
   }
   if (query && toolName === "webSearch") {
-    return `Searching web for "${query}"`;
+    return makeAssistantStatus("searching", `"${query}"`);
   }
   if (query && provider && toolName === "searchTools") {
-    return `Searching ${provider} tools for "${query}"`;
+    return makeAssistantStatus("searching", `${provider} "${query}"`);
   }
   if (query && toolName === "searchTools") {
-    return `Searching tools for "${query}"`;
+    return makeAssistantStatus("searching", `"${query}"`);
   }
   if (domain && toolName === "webFetch") {
-    return `Fetching page from ${domain}`;
+    return makeAssistantStatus("fetching", domain);
+  }
+  const known = {
+    loadSkill: makeAssistantStatus("loading", "skill instructions"),
+    systemTime: makeAssistantStatus("reading", "system time"),
+    bash: makeAssistantStatus("running", "shell"),
+    readFile: makeAssistantStatus("reading", "file"),
+    writeFile: makeAssistantStatus("updating", "file"),
+    webSearch: makeAssistantStatus("searching", "sources"),
+    webFetch: makeAssistantStatus("fetching", "pages"),
+    slackChannelPostMessage: makeAssistantStatus("posting", "channel"),
+    slackMessageAddReaction: makeAssistantStatus("adding", "reaction"),
+    slackChannelListMessages: makeAssistantStatus("listing", "messages"),
+    slackCanvasCreate: makeAssistantStatus("creating", "brief"),
+    slackCanvasUpdate: makeAssistantStatus("updating", "brief"),
+    slackListCreate: makeAssistantStatus("creating", "tracking list"),
+    slackListAddItems: makeAssistantStatus("updating", "tracking list"),
+    slackListUpdateItem: makeAssistantStatus("updating", "tracking list"),
+    imageGenerate: makeAssistantStatus("creating", "image"),
+    searchTools: makeAssistantStatus(
+      "searching",
+      provider ? `${provider} tools` : "tools"
+    )
+  };
+  if (known[toolName]) {
+    return known[toolName];
+  }
+  const mcpMatch = /^mcp__([^_]+)__(.+)$/.exec(toolName);
+  if (mcpMatch) {
+    return makeAssistantStatus("running", `${mcpMatch[1]}/${mcpMatch[2]}`);
   }
-  return formatToolStatus(toolName);
+  const readable = toolName.replaceAll("_", " ").trim();
+  return makeAssistantStatus("running", readable || "tool");
 }
 
 // src/chat/tools/execution/build-sandbox-input.ts
@@ -8432,7 +8795,7 @@ function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor
         turnId: spanContext.turnId,
         agentId: spanContext.agentId
       };
-      await onStatus?.(`${formatToolStatusWithInput(toolName, params)}...`);
+      await onStatus?.(buildToolStatus(toolName, params));
       return withSpan(
         `execute_tool ${toolName}`,
         "gen_ai.execute_tool",
@@ -9027,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 = {
@@ -9098,7 +9469,8 @@ async function generateAssistantReply(messageText, context = {}) {
       requesterId: context.requester?.userId,
       resolveConfiguration: async (key) => configurationValues[key]
     });
-    const sandboxExecutor = createSandboxExecutor({
+    const providerAuthActions = /* @__PURE__ */ new Map();
+    sandboxExecutor = createSandboxExecutor({
       sandboxId: context.sandbox?.sandboxId,
       sandboxDependencyProfileHash: context.sandbox?.sandboxDependencyProfileHash,
       traceContext: spanContext,
@@ -9113,6 +9485,7 @@ async function generateAssistantReply(messageText, context = {}) {
           threadTs: context.correlation?.threadTs,
           userMessage: userInput,
           userTokenStore: createUserTokenStore(),
+          providerAuthActions,
           onConfigurationValueChanged: (key, value) => {
             if (value === void 0) {
               delete configurationValues[key];
@@ -9124,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) {
@@ -9201,11 +9616,6 @@ async function generateAssistantReply(messageText, context = {}) {
         onArtifactStatePatch: (patch) => {
           Object.assign(artifactStatePatch, patch);
         },
-        onToolCallStart: async (toolName, input) => {
-          await context.onStatus?.(
-            `${formatToolStatusWithInput(toolName, input)}...`
-          );
-        },
         toolOverrides: context.toolOverrides,
         onSkillLoaded: async (loadedSkill) => {
           const resolvedSkill = await skillSandbox.loadSkill(loadedSkill.name);
@@ -9271,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)
         });
       }
     }
@@ -9477,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,
@@ -9529,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,
@@ -9559,90 +9984,173 @@ async function generateAssistantReply(messageText, context = {}) {
   }
 }
 
-// src/handlers/oauth-resume.ts
-function resolveReplyTimeoutMs(explicitTimeoutMs) {
-  if (typeof explicitTimeoutMs === "number" && explicitTimeoutMs > 0) {
-    return explicitTimeoutMs;
-  }
-  const raw = process.env.EVAL_AGENT_REPLY_TIMEOUT_MS?.trim();
-  if (!raw) {
-    return void 0;
-  }
-  const parsed = Number.parseInt(raw, 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
-}
-async function postSlackMessage(channelId, threadTs, text) {
-  try {
-    await getSlackClient().chat.postMessage({
-      channel: channelId,
-      thread_ts: threadTs,
-      text
-    });
-  } catch {
-  }
-}
-async function setAssistantStatus(channelId, threadTs, status) {
-  try {
-    await getSlackClient().assistant.threads.setStatus({
-      channel_id: channelId,
-      thread_ts: threadTs,
-      status
-    });
-  } catch {
-  }
-}
-var STATUS_DEBOUNCE_MS = 1e3;
-function createDebouncedStatusPoster(channelId, threadTs) {
-  let lastPostAt = 0;
-  let currentStatus = "";
+// src/chat/runtime/progress-reporter.ts
+var STATUS_UPDATE_DEBOUNCE_MS = 1e3;
+var STATUS_MIN_VISIBLE_MS = 1200;
+var STATUS_ROTATION_INTERVAL_MS = 3e4;
+function createProgressReporter(args) {
+  const now = args.now ?? (() => Date.now());
+  const setTimer = args.setTimer ?? ((callback, delayMs) => setTimeout(callback, delayMs));
+  const clearTimer = args.clearTimer ?? ((timer) => clearTimeout(timer));
+  const random = args.random ?? Math.random;
+  let active = false;
+  let currentKey = "";
+  let currentStatus = makeAssistantStatus("thinking");
+  let currentVisibleStatus = "";
+  let lastStatusAt = 0;
   let pendingStatus = null;
+  let pendingKey = "";
   let pendingTimer = null;
-  let stopped = false;
-  const flush = async () => {
-    if (stopped || !pendingStatus) return;
-    const status = pendingStatus;
-    pendingStatus = null;
-    pendingTimer = null;
-    lastPostAt = Date.now();
-    currentStatus = status;
-    await setAssistantStatus(channelId, threadTs, status);
-  };
-  const post = async (status) => {
-    if (stopped) return;
-    const truncated = truncateStatusText(status);
-    if (!truncated || truncated === currentStatus) return;
-    const now = Date.now();
-    const elapsed = now - lastPostAt;
-    if (elapsed >= STATUS_DEBOUNCE_MS) {
-      if (pendingTimer) {
-        clearTimeout(pendingTimer);
-        pendingTimer = null;
+  let rotationTimer = null;
+  let inflightStatusUpdate = Promise.resolve();
+  const scheduleRotation = () => {
+    if (rotationTimer) {
+      clearTimer(rotationTimer);
+      rotationTimer = null;
+    }
+    if (!active || !currentVisibleStatus) {
+      return;
+    }
+    rotationTimer = setTimer(() => {
+      rotationTimer = null;
+      if (!active || !currentVisibleStatus) {
+        return;
       }
-      pendingStatus = null;
-      lastPostAt = now;
-      currentStatus = truncated;
-      await setAssistantStatus(channelId, threadTs, truncated);
+      void postRenderedStatus(currentStatus);
+    }, STATUS_ROTATION_INTERVAL_MS);
+  };
+  const postStatus = async (text, suggestions) => {
+    const channelId = args.channelId;
+    const threadTs = args.threadTs;
+    if (!channelId || !threadTs) {
       return;
     }
-    pendingStatus = truncated;
-    if (!pendingTimer) {
-      pendingTimer = setTimeout(
-        () => {
-          void flush();
-        },
-        Math.max(1, STATUS_DEBOUNCE_MS - elapsed)
-      );
+    if (!text && !currentVisibleStatus) {
+      return;
     }
+    currentVisibleStatus = text;
+    lastStatusAt = now();
+    scheduleRotation();
+    const previous = inflightStatusUpdate;
+    const request = (async () => {
+      await previous;
+      await args.transport.setStatus(channelId, threadTs, text, suggestions);
+    })();
+    inflightStatusUpdate = request;
+    await request;
+  };
+  const postRenderedStatus = async (status) => {
+    const presentation = buildAssistantStatusPresentation({
+      status,
+      random
+    });
+    currentStatus = status;
+    currentKey = presentation.key;
+    await postStatus(presentation.visible, presentation.suggestions);
   };
-  post.stop = () => {
-    stopped = true;
+  const clearPending = () => {
     if (pendingTimer) {
-      clearTimeout(pendingTimer);
+      clearTimer(pendingTimer);
       pendingTimer = null;
     }
     pendingStatus = null;
+    pendingKey = "";
+  };
+  const flushPending = async () => {
+    if (!active || !pendingStatus) {
+      clearPending();
+      return;
+    }
+    const next = pendingStatus;
+    clearPending();
+    const nextPresentation = buildAssistantStatusPresentation({
+      status: next,
+      random
+    });
+    if (nextPresentation.key !== currentKey) {
+      await postRenderedStatus(next);
+    }
+  };
+  return {
+    async start() {
+      active = true;
+      clearPending();
+      currentStatus = makeAssistantStatus("thinking");
+      currentKey = "";
+      void postRenderedStatus(currentStatus);
+    },
+    async stop() {
+      active = false;
+      clearPending();
+      if (rotationTimer) {
+        clearTimer(rotationTimer);
+        rotationTimer = null;
+      }
+      currentKey = "";
+      await postStatus("");
+    },
+    async setStatus(status) {
+      if (!active) {
+        return;
+      }
+      const presentation = buildAssistantStatusPresentation({
+        status,
+        random
+      });
+      if (!presentation.visible) {
+        return;
+      }
+      if (presentation.key === currentKey || presentation.key === pendingKey) {
+        return;
+      }
+      const elapsed = now() - lastStatusAt;
+      const waitMs = Math.max(
+        STATUS_UPDATE_DEBOUNCE_MS - elapsed,
+        STATUS_MIN_VISIBLE_MS - elapsed,
+        0
+      );
+      if (waitMs <= 0) {
+        clearPending();
+        void postRenderedStatus(status);
+        return;
+      }
+      pendingStatus = status;
+      pendingKey = presentation.key;
+      if (pendingTimer) {
+        return;
+      }
+      pendingTimer = setTimer(
+        () => {
+          pendingTimer = null;
+          void flushPending();
+        },
+        Math.max(1, waitMs)
+      );
+    }
   };
-  return post;
+}
+
+// src/handlers/oauth-resume.ts
+function resolveReplyTimeoutMs(explicitTimeoutMs) {
+  if (typeof explicitTimeoutMs === "number" && explicitTimeoutMs > 0) {
+    return explicitTimeoutMs;
+  }
+  const raw = process.env.EVAL_AGENT_REPLY_TIMEOUT_MS?.trim();
+  if (!raw) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+async function postSlackMessage(channelId, threadTs, text) {
+  try {
+    await getSlackClient().chat.postMessage({
+      channel: channelId,
+      thread_ts: threadTs,
+      text
+    });
+  } catch {
+  }
 }
 function createReadOnlyConfigService(values) {
   const entries = Object.entries(values).map(([key, value]) => ({
@@ -9671,9 +10179,13 @@ function createReadOnlyConfigService(values) {
   };
 }
 async function resumeAuthorizedRequest(args) {
-  const postStatus = createDebouncedStatusPoster(args.channelId, args.threadTs);
+  const progress = createProgressReporter({
+    channelId: args.channelId,
+    threadTs: args.threadTs,
+    transport: createSlackWebApiAssistantStatusTransport()
+  });
   await postSlackMessage(args.channelId, args.threadTs, args.connectedText);
-  await setAssistantStatus(args.channelId, args.threadTs, "Thinking...");
+  await progress.start();
   try {
     const generateReply = args.generateReply ?? generateAssistantReply;
     const replyPromise = generateReply(args.messageText, {
@@ -9691,7 +10203,7 @@ async function resumeAuthorizedRequest(args) {
       artifactState: args.artifactState,
       configuration: args.configuration,
       channelConfiguration: args.configuration ? createReadOnlyConfigService(args.configuration) : void 0,
-      onStatus: postStatus
+      onStatus: (status) => progress.setStatus(status)
     });
     const replyTimeoutMs = resolveReplyTimeoutMs(args.replyTimeoutMs);
     const reply = typeof replyTimeoutMs === "number" ? await Promise.race([
@@ -9707,8 +10219,7 @@ async function resumeAuthorizedRequest(args) {
         )
       )
     ]) : await replyPromise;
-    postStatus.stop();
-    await setAssistantStatus(args.channelId, args.threadTs, "");
+    await progress.stop();
     if (args.onReply) {
       await args.onReply(reply);
     } else if (reply.text) {
@@ -9716,8 +10227,7 @@ async function resumeAuthorizedRequest(args) {
     }
     await args.onSuccess?.(reply);
   } catch (error) {
-    postStatus.stop();
-    await setAssistantStatus(args.channelId, args.threadTs, "");
+    await progress.stop();
     if (isRetryableTurnError(error, "mcp_auth_resume") && args.onAuthPause) {
       await args.onAuthPause(error);
       return;
@@ -10049,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;
@@ -10064,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);
     }
@@ -10414,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,
@@ -10422,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, "\\$&");
 }
@@ -10458,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();
@@ -10508,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) {
@@ -10570,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)) {
@@ -10590,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 ?? "",
@@ -10612,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 {
@@ -10634,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 */,
@@ -11229,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();
@@ -11265,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",
         {
@@ -11292,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 ?? "",
@@ -11328,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",
@@ -11342,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),
@@ -11355,6 +12086,9 @@ async function summarizeConversationImage(args, deps) {
   }
 }
 async function hydrateConversationVisionContextWithDeps(conversation, context, deps) {
+  if (!isVisionEnabled()) {
+    return;
+  }
   if (!context.channelId || !context.threadTs) {
     return;
   }
@@ -11555,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,
@@ -11593,111 +12328,6 @@ function createJuniorRuntimeServices(overrides = {}) {
   };
 }
 
-// src/chat/runtime/progress-reporter.ts
-var STATUS_UPDATE_DEBOUNCE_MS = 1e3;
-var STATUS_MIN_VISIBLE_MS = 1200;
-function createProgressReporter(args) {
-  const now = args.now ?? (() => Date.now());
-  const setTimer = args.setTimer ?? ((callback, delayMs) => setTimeout(callback, delayMs));
-  const clearTimer = args.clearTimer ?? ((timer) => clearTimeout(timer));
-  let active = false;
-  let currentStatus = "";
-  let lastStatusAt = 0;
-  let pendingStatus = null;
-  let pendingTimer = null;
-  let inflightStatusUpdate = Promise.resolve();
-  const postStatus = async (text) => {
-    const channelId = args.channelId;
-    const threadTs = args.threadTs;
-    if (!channelId || !threadTs) {
-      return;
-    }
-    if (!text && !currentStatus) {
-      return;
-    }
-    currentStatus = text;
-    lastStatusAt = now();
-    const suggestions = text ? [text] : void 0;
-    const previous = inflightStatusUpdate;
-    const request = (async () => {
-      await previous;
-      try {
-        await args.setAssistantStatus(channelId, threadTs, text, suggestions);
-      } catch (error) {
-        logWarn(
-          "assistant_status_update_failed",
-          {},
-          {
-            "app.slack.status_text": text || "(clear)",
-            "error.message": error instanceof Error ? error.message : String(error)
-          },
-          "Failed to update assistant status"
-        );
-      }
-    })();
-    inflightStatusUpdate = request;
-    await request;
-  };
-  const clearPending = () => {
-    if (pendingTimer) {
-      clearTimer(pendingTimer);
-      pendingTimer = null;
-    }
-    pendingStatus = null;
-  };
-  const flushPending = async () => {
-    if (!active || !pendingStatus) {
-      clearPending();
-      return;
-    }
-    const next = pendingStatus;
-    clearPending();
-    if (next !== currentStatus) {
-      await postStatus(next);
-    }
-  };
-  return {
-    async start() {
-      active = true;
-      clearPending();
-      void postStatus("Thinking...");
-    },
-    async stop() {
-      active = false;
-      clearPending();
-      await postStatus("");
-    },
-    async setStatus(text) {
-      const truncated = truncateStatusText(text);
-      if (!active || !truncated || truncated === currentStatus || truncated === pendingStatus) {
-        return;
-      }
-      const elapsed = now() - lastStatusAt;
-      const waitMs = Math.max(
-        STATUS_UPDATE_DEBOUNCE_MS - elapsed,
-        STATUS_MIN_VISIBLE_MS - elapsed,
-        0
-      );
-      if (waitMs <= 0) {
-        clearPending();
-        void postStatus(truncated);
-        return;
-      }
-      pendingStatus = truncated;
-      if (pendingTimer) {
-        return;
-      }
-      pendingTimer = setTimer(
-        () => {
-          pendingTimer = null;
-          void flushPending();
-        },
-        Math.max(1, waitMs)
-      );
-    }
-  };
-}
-
 // src/chat/runtime/streaming.ts
 function createTextStreamBridge() {
   const queue = [];
@@ -11738,36 +12368,6 @@ function createTextStreamBridge() {
     }
   };
 }
-function createNormalizingStream(inner, normalize) {
-  return {
-    async *[Symbol.asyncIterator]() {
-      let accumulated = "";
-      let emitted = 0;
-      for await (const chunk of inner) {
-        accumulated += chunk;
-        const lastNewline = accumulated.lastIndexOf("\n");
-        if (lastNewline === -1) {
-          const delta2 = accumulated.slice(emitted);
-          if (delta2) {
-            yield delta2;
-            emitted = accumulated.length;
-          }
-          continue;
-        }
-        const stable = accumulated.slice(0, lastNewline + 1);
-        const normalized = normalize(stable);
-        const delta = normalized.slice(emitted);
-        emitted = normalized.length;
-        if (delta) yield delta;
-      }
-      if (accumulated) {
-        const normalized = normalize(accumulated);
-        const delta = normalized.slice(emitted);
-        if (delta) yield delta;
-      }
-    }
-  };
-}
 
 // src/chat/runtime/reply-executor.ts
 function getExecutionFailureReason(reply) {
@@ -11869,19 +12469,23 @@ 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({
           channelId,
           threadTs,
-          setAssistantStatus: (channel, thread2, text, suggestions) => deps.getSlackAdapter().setAssistantStatus(channel, thread2, text, suggestions)
+          transport: createSlackAdapterAssistantStatusTransport({
+            getSlackAdapter: deps.getSlackAdapter
+          })
         });
         const textStream = createTextStreamBridge();
         let streamedReplyPromise;
@@ -11898,10 +12502,7 @@ function createReplyToThread(deps) {
           if (!streamedReplyPromise) {
             const streamingReply = (async () => {
               return await postThreadReply(
-                createNormalizingStream(
-                  textStream.iterable,
-                  ensureBlockSpacing
-                ),
+                textStream.iterable,
                 "streaming_initial_post"
               );
             })();
@@ -12286,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,
@@ -12333,6 +12934,7 @@ function createSlackRuntime(options) {
   const replyToThread = createReplyToThread({
     getSlackAdapter: options.getSlackAdapter,
     prepareTurnState,
+    resolveUserAttachments: services.visionContext.resolveUserAttachments,
     services: services.replyExecutor
   });
   return createSlackTurnRuntime({