@sentry/junior 0.27.0 → 0.27.2

package/dist/app.js

@@ -2701,135 +2701,6 @@ function truncateStatusText(text) {
   }
   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/slack/mrkdwn.ts
 function ensureBlockSpacing(text) {
@@ -3483,7 +3354,7 @@ function buildSystemPrompt(params) {
       [
         "- For factual or external questions, run tools/skills first, then answer from evidence.",
         "- Use tool descriptions as the source of truth for when each tool should or should not be called.",
-        "- Use `reportProgress` only when you start a major new phase of work, such as researching, reading, executing, reviewing, or drafting. Do not call it for every tool or small substep.",
+        "- Use `reportProgress` only for sparse, meaningful progress updates. Pass a short user-facing status message, and do not call it for every tool or small substep.",
         "- When using CLI tools through `bash`, prefer deterministic non-interactive flags and avoid commands that wait for prompts or editors.",
         "- Keep routine setup and research steps silent in user-facing replies. Do not narrate duplicate checks, credential issuance, file writes, or similar internal progress unless the result is user-relevant.",
         "- If a routine prerequisite check finds nothing notable, omit it entirely from the final reply and report only the user-relevant outcome.",
@@ -3538,6 +3409,10 @@ function buildSystemPrompt(params) {
         "- Use Slack-friendly markdown, not full CommonMark. Prefer bold section labels over markdown headings, and use bullets and short code blocks when helpful.",
         "- Keep normal responses brief and scannable.",
         "- If depth is needed, start with a concise summary and then provide fuller detail.",
+        "- Prefer a single compact thread reply when the full answer comfortably fits within this inline budget.",
+        "- When canvas creation is available and a research or document-style answer would likely need continuation, multiple sections, or future reference value, create a Slack canvas and keep the thread reply to a short summary plus the canvas link.",
+        "- Typical canvas-first cases include long-form research summaries, timelines, bios or profiles, structured notes, plans, comparisons, and other reusable reference documents.",
+        "- Do not create a canvas for short factual answers that fit cleanly in one normal thread reply.",
         "- For tool-heavy research, discovery, or source-checking requests, do not send an initial acknowledgment. Start the visible reply only once you can present the actual answer.",
         "- Do not narrate tool execution or repeated status updates in the visible reply.",
         "- Avoid tables and markdown links like `[label](url)` unless explicitly requested. Prefer plain URLs or Slack-native entities when exact rendering matters.",
@@ -5193,23 +5068,12 @@ function createReadFileTool() {
 import { Type as Type6 } from "@sinclair/typebox";
 function createReportProgressTool() {
   return tool({
-    description: "Update assistant status when you start a major new phase of work. Use for sparse phase changes such as researching, reading, executing, reviewing, or drafting. Do not call this for every tool or minor substep.",
+    description: "Update assistant status with a short user-facing progress message. Use this sparingly for meaningful progress changes, not for every tool call or minor substep.",
     inputSchema: Type6.Object({
-      phase: Type6.Union([
-        Type6.Literal("thinking"),
-        Type6.Literal("researching"),
-        Type6.Literal("reading"),
-        Type6.Literal("executing"),
-        Type6.Literal("reviewing"),
-        Type6.Literal("drafting")
-      ]),
-      detail: Type6.Optional(
-        Type6.String({
-          minLength: 1,
-          maxLength: 40,
-          description: "Optional short user-facing detail, such as docs, tests, source files, or reply."
-        })
-      )
+      message: Type6.String({
+        minLength: 1,
+        description: "Short user-facing progress message. The UI truncates it if needed."
+      })
     })
   });
 }
@@ -5805,7 +5669,7 @@ function mergeRecentCanvases(existing, created) {
 }
 function createSlackCanvasCreateTool(context, state) {
   return tool({
-    description: "Create a Slack canvas for long-form output in the active assistant context channel. Use when content is too long for a thread reply or needs a persistent document. Do not use for short answers that fit in-thread.",
+    description: "Create a Slack canvas for long-form output in the active assistant context channel. Use when the answer is better as a reusable document than a thread reply: long-form research, timelines, bios/profiles, structured notes, plans, comparisons, or anything likely to exceed one compact Slack reply. After creating it, keep the thread reply brief and include the canvas link. Do not use for short answers that fit cleanly in one normal thread reply.",
     inputSchema: Type11.Object({
       title: Type11.String({
         minLength: 1,
@@ -7254,563 +7118,144 @@ function throwSandboxOperationError(action, error, includeMissingPath = false) {
 import { Sandbox } from "@vercel/sandbox";
 import { createBashTool as createBashTool2 } from "bash-tool";
 
-// src/chat/slack/assistant-thread/status-render.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"]
-  },
-  drafting: {
-    defaultContext: "reply",
-    variants: ["Drafting", "Writing", "Composing", "Shaping"]
-  },
-  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"]
+// src/chat/sandbox/skill-sync.ts
+import fs3 from "fs/promises";
+import path5 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);
+    }
   }
-};
-function makeAssistantStatus(kind, context, options) {
-  return {
-    kind,
-    ...context ? { context } : {},
-    ...options?.source ? { source: options.source } : {}
-  };
+  return undefined;
 }
-function renderAssistantStatus(args) {
-  const random = args.random ?? Math.random;
-  const pattern = STATUS_PATTERNS[args.status.kind];
-  const source = args.status.source ?? "fallback";
-  const context = normalizeSlackStatusText(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}`);
+
+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("=")) {
+      continue;
+    }
+    if (value.startsWith("-")) {
+      continue;
+    }
+    values.push(value);
+  }
+  return values;
+}
+
+function loadState() {
+  try {
+    return JSON.parse(fs.readFileSync(statePath, "utf8"));
+  } catch {
+    return { nextIssueNumber: 101, issues: {} };
+  }
+}
+
+function saveState(state) {
+  fs.mkdirSync(path.dirname(statePath), { recursive: true });
+  fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+}
+
+function issueUrl(repo, number) {
+  return "https://github.com/" + repo + "/issues/" + number;
+}
+
+function repoValue() {
+  return getFlag("--repo") || "getsentry/junior";
+}
+
+function readBody() {
+  const bodyFile = getFlag("--body-file");
+  if (bodyFile) {
+    try {
+      return fs.readFileSync(bodyFile, "utf8");
+    } catch {
+      return "";
+    }
+  }
+  return getFlag("--body") || "";
+}
+
+function defaultIssue(repo, number) {
   return {
-    key: `${source}:${args.status.kind}:${context}`,
-    visible
+    number,
+    title: "Eval issue",
+    body: "",
+    state: "OPEN",
+    url: issueUrl(repo, number),
+    labels: [],
+    assignees: [],
+    author: { login: "junior-eval" },
   };
 }
-function selectAssistantLoadingMessages(args) {
-  const random = args.random ?? Math.random;
-  const normalized = Array.from(
-    new Set(
-      args.messages.map((message) => truncateStatusText(normalizeSlackStatusText(message))).filter((message) => message.length > 0)
-    )
-  );
-  if (normalized.length === 0) {
-    return void 0;
+
+function pickFields(record, csv) {
+  if (!csv) {
+    return record;
   }
-  const shuffled = [...normalized];
-  for (let index = shuffled.length - 1; index > 0; index -= 1) {
-    const otherIndex = Math.floor(random() * (index + 1));
-    [shuffled[index], shuffled[otherIndex]] = [
-      shuffled[otherIndex],
-      shuffled[index]
-    ];
+  return Object.fromEntries(
+    csv
+      .split(",")
+      .map((value) => value.trim())
+      .filter(Boolean)
+      .map((key) => [key, key in record ? record[key] : null]),
+  );
+}
+
+function outputJson(value) {
+  fs.writeFileSync(process.stdout.fd, JSON.stringify(value, null, 2) + "\\n");
+}
+
+function outputText(value) {
+  fs.writeFileSync(process.stdout.fd, value);
+}
+
+function fallbackToRealGh() {
+  for (const binary of fallbackBinaries) {
+    if (!fs.existsSync(binary)) {
+      continue;
+    }
+    const result = spawnSync(binary, args, { stdio: "inherit" });
+    process.exit(result.status ?? 1);
   }
-  return shuffled.slice(0, 10);
-}
-
-// src/chat/slack/assistant-thread/status-scheduler.ts
-var STATUS_UPDATE_DEBOUNCE_MS = 1e3;
-var STATUS_MIN_VISIBLE_MS = 1200;
-var STATUS_ROTATION_INTERVAL_MS = 3e4;
-function createAssistantStatusScheduler(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;
-  const loadingMessages = selectAssistantLoadingMessages({
-    messages: args.loadingMessages ?? [],
-    random
-  });
-  const defaultStatus = makeAssistantStatus("thinking");
-  let active = false;
-  let currentKey = "";
-  let currentStatus = defaultStatus;
-  let currentVisibleStatus = "";
-  let currentLoadingMessages;
-  let lastStatusAt = 0;
-  let pendingStatus = null;
-  let pendingKey = "";
-  let pendingTimer = null;
-  let rotationTimer = null;
-  let inflightStatusUpdate = Promise.resolve();
-  const enqueueStatusUpdate = (task) => {
-    const request = inflightStatusUpdate.catch(() => void 0).then(async () => {
-      await task();
-    });
-    inflightStatusUpdate = request.catch(() => void 0);
-    return request;
-  };
-  const scheduleRotation = () => {
-    if (rotationTimer) {
-      clearTimer(rotationTimer);
-      rotationTimer = null;
-    }
-    if (!active || !currentVisibleStatus) {
-      return;
-    }
-    rotationTimer = setTimer(() => {
-      rotationTimer = null;
-      if (!active || !currentVisibleStatus) {
-        return;
-      }
-      void postStatus(currentVisibleStatus, currentLoadingMessages);
-    }, STATUS_ROTATION_INTERVAL_MS);
-  };
-  const getLoadingMessagesForStatus = (_status, visible) => {
-    if (!visible) {
-      return void 0;
-    }
-    return [visible];
-  };
-  const getInitialStatusText = () => {
-    if (loadingMessages?.length) {
-      return loadingMessages[0];
-    }
-    return renderAssistantStatus({
-      status: defaultStatus,
-      random
-    }).visible;
-  };
-  const haveSameLoadingMessages = (left, right) => {
-    if (left === right) {
-      return true;
-    }
-    if (!left || !right || left.length !== right.length) {
-      return false;
-    }
-    return left.every((message, index) => message === right[index]);
-  };
-  const postStatus = async (text, nextLoadingMessages) => {
-    if (!text && !currentVisibleStatus) {
-      return;
-    }
-    currentVisibleStatus = text;
-    currentLoadingMessages = nextLoadingMessages;
-    lastStatusAt = now();
-    scheduleRotation();
-    await enqueueStatusUpdate(async () => {
-      await args.sendStatus(text, nextLoadingMessages);
-    });
-  };
-  const postRenderedStatus = async (status) => {
-    const presentation = renderAssistantStatus({
-      status,
-      random
-    });
-    const nextLoadingMessages = getLoadingMessagesForStatus(
-      status,
-      presentation.visible
-    );
-    currentStatus = status;
-    currentKey = presentation.key;
-    await postStatus(presentation.visible, nextLoadingMessages);
-  };
-  const clearPending = () => {
-    if (pendingTimer) {
-      clearTimer(pendingTimer);
-      pendingTimer = null;
-    }
-    pendingStatus = null;
-    pendingKey = "";
-  };
-  const flushPending = async () => {
-    if (!active || !pendingStatus) {
-      clearPending();
-      return;
-    }
-    const next = pendingStatus;
-    clearPending();
-    const nextPresentation = renderAssistantStatus({
-      status: next,
-      random
-    });
-    if (nextPresentation.key !== currentKey) {
-      await postRenderedStatus(next);
-    }
-  };
-  return {
-    start() {
-      active = true;
-      clearPending();
-      currentStatus = defaultStatus;
-      currentKey = "initial";
-      void postStatus(getInitialStatusText(), loadingMessages);
-    },
-    async stop() {
-      active = false;
-      clearPending();
-      if (rotationTimer) {
-        clearTimer(rotationTimer);
-        rotationTimer = null;
-      }
-      currentKey = "";
-      await postStatus("");
-    },
-    update(status) {
-      if (!active) {
-        return;
-      }
-      const presentation = renderAssistantStatus({
-        status,
-        random
-      });
-      if (!presentation.visible) {
-        return;
-      }
-      if (status.source !== "major" && (currentStatus.source === "major" || pendingStatus?.source === "major")) {
-        return;
-      }
-      if (presentation.key === currentKey || presentation.key === pendingKey) {
-        return;
-      }
-      if (presentation.visible === currentVisibleStatus) {
-        clearPending();
-        currentStatus = status;
-        currentKey = presentation.key;
-        const nextLoadingMessages = getLoadingMessagesForStatus(
-          status,
-          presentation.visible
-        );
-        if (!haveSameLoadingMessages(currentLoadingMessages, nextLoadingMessages)) {
-          void postStatus(presentation.visible, nextLoadingMessages);
-        }
-        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)
-      );
-    }
-  };
-}
-
-// src/chat/slack/assistant-thread/status-send.ts
-var SLACK_ASSISTANT_ACTIVE_STATUS = "is working on your request...";
-function createSlackAdapterStatusSender(args) {
-  const adapter = args.getSlackAdapter();
-  const boundToken = getSlackAdapterRequestToken(adapter);
-  return async (text, loadingMessages) => {
-    const channelId = args.channelId;
-    const threadTs = args.threadTs;
-    if (!channelId || !threadTs) {
-      return;
-    }
-    const normalizedChannelId = normalizeSlackConversationId(channelId);
-    if (!normalizedChannelId) {
-      return;
-    }
-    const nextLoadingMessages = text ? loadingMessages ?? [text] : void 0;
-    try {
-      await runWithBoundSlackToken(
-        adapter,
-        boundToken,
-        () => adapter.setAssistantStatus(
-          normalizedChannelId,
-          threadTs,
-          text ? SLACK_ASSISTANT_ACTIVE_STATUS : "",
-          nextLoadingMessages
-        )
-      );
-    } catch (error) {
-      logAssistantStatusFailure({
-        status: text,
-        error,
-        channelId,
-        normalizedChannelId,
-        threadTs
-      });
-    }
-  };
-}
-function createSlackWebApiStatusSender(args) {
-  const getClient2 = args.getSlackClient ?? getSlackClient;
-  return async (text, loadingMessages) => {
-    const channelId = args.channelId;
-    const threadTs = args.threadTs;
-    if (!channelId || !threadTs) {
-      return;
-    }
-    const normalizedChannelId = normalizeSlackConversationId(channelId);
-    if (!normalizedChannelId) {
-      return;
-    }
-    const nextLoadingMessages = text ? loadingMessages ?? [text] : void 0;
-    try {
-      await getClient2().assistant.threads.setStatus({
-        channel_id: normalizedChannelId,
-        thread_ts: threadTs,
-        status: text ? SLACK_ASSISTANT_ACTIVE_STATUS : "",
-        ...nextLoadingMessages ? { loading_messages: nextLoadingMessages } : {}
-      });
-    } catch (error) {
-      logAssistantStatusFailure({
-        status: text,
-        error,
-        channelId,
-        normalizedChannelId,
-        threadTs
-      });
-    }
-  };
-}
-function getSlackAdapterRequestToken(adapter) {
-  const token = adapter.requestContext?.getStore()?.token;
-  if (typeof token !== "string") {
-    return void 0;
-  }
-  const trimmed = token.trim();
-  return trimmed || void 0;
-}
-async function runWithBoundSlackToken(adapter, token, task) {
-  if (!token) {
-    return await task();
-  }
-  return await adapter.withBotToken(token, task);
-}
-function logAssistantStatusFailure(args) {
-  logWarn(
-    "assistant_status_update_failed",
-    {},
-    {
-      "app.slack.status_text": args.status || "(clear)",
-      "app.slack.channel_id_raw": args.channelId,
-      "app.slack.channel_id": args.normalizedChannelId,
-      "app.slack.thread_ts": args.threadTs,
-      "error.message": args.error instanceof Error ? args.error.message : String(args.error)
-    },
-    `Failed to update assistant status channel=${args.normalizedChannelId} raw=${args.channelId} thread=${args.threadTs}`
-  );
-}
-
-// src/chat/slack/assistant-thread/status.ts
-function createSlackAdapterAssistantStatusSession(args) {
-  return createAssistantStatusScheduler({
-    sendStatus: createSlackAdapterStatusSender({
-      channelId: args.channelId,
-      threadTs: args.threadTs,
-      getSlackAdapter: args.getSlackAdapter
-    }),
-    loadingMessages: args.loadingMessages ?? botConfig.loadingMessages,
-    now: args.now,
-    setTimer: args.setTimer,
-    clearTimer: args.clearTimer,
-    random: args.random
-  });
-}
-function createSlackWebApiAssistantStatusSession(args) {
-  return createAssistantStatusScheduler({
-    sendStatus: createSlackWebApiStatusSender({
-      channelId: args.channelId,
-      threadTs: args.threadTs,
-      getSlackClient: args.getSlackClient
-    }),
-    loadingMessages: args.loadingMessages ?? botConfig.loadingMessages,
-    now: args.now,
-    setTimer: args.setTimer,
-    clearTimer: args.clearTimer,
-    random: args.random
-  });
-}
-
-// src/chat/sandbox/skill-sync.ts
-import fs3 from "fs/promises";
-import path5 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("=")) {
-      continue;
-    }
-    if (value.startsWith("-")) {
-      continue;
-    }
-    values.push(value);
-  }
-  return values;
-}
-
-function loadState() {
-  try {
-    return JSON.parse(fs.readFileSync(statePath, "utf8"));
-  } catch {
-    return { nextIssueNumber: 101, issues: {} };
-  }
-}
-
-function saveState(state) {
-  fs.mkdirSync(path.dirname(statePath), { recursive: true });
-  fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
-}
-
-function issueUrl(repo, number) {
-  return "https://github.com/" + repo + "/issues/" + number;
-}
-
-function repoValue() {
-  return getFlag("--repo") || "getsentry/junior";
-}
-
-function readBody() {
-  const bodyFile = getFlag("--body-file");
-  if (bodyFile) {
-    try {
-      return fs.readFileSync(bodyFile, "utf8");
-    } catch {
-      return "";
-    }
-  }
-  return getFlag("--body") || "";
-}
-
-function defaultIssue(repo, number) {
-  return {
-    number,
-    title: "Eval issue",
-    body: "",
-    state: "OPEN",
-    url: issueUrl(repo, number),
-    labels: [],
-    assignees: [],
-    author: { login: "junior-eval" },
-  };
-}
-
-function pickFields(record, csv) {
-  if (!csv) {
-    return record;
-  }
-  return Object.fromEntries(
-    csv
-      .split(",")
-      .map((value) => value.trim())
-      .filter(Boolean)
-      .map((key) => [key, key in record ? record[key] : null]),
-  );
-}
-
-function outputJson(value) {
-  fs.writeFileSync(process.stdout.fd, JSON.stringify(value, null, 2) + "\\n");
-}
-
-function outputText(value) {
-  fs.writeFileSync(process.stdout.fd, value);
-}
-
-function fallbackToRealGh() {
-  for (const binary of fallbackBinaries) {
-    if (!fs.existsSync(binary)) {
-      continue;
-    }
-    const result = spawnSync(binary, args, { stdio: "inherit" });
-    process.exit(result.status ?? 1);
-  }
-  process.stderr.write("gh stub: unsupported command\\n");
-  process.exit(1);
+  process.stderr.write("gh stub: unsupported command\\n");
+  process.exit(1);
 }
 
 if (args.length === 0 || args[0] === "--version" || args[0] === "version") {
@@ -8233,12 +7678,6 @@ 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;
@@ -8279,26 +7718,6 @@ function sleep2(ms) {
     setTimeout(resolve, ms);
   });
 }
-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",
@@ -8316,23 +7735,6 @@ function createSandboxSessionManager(options) {
   const traceContext = options?.traceContext ?? {};
   const dependencyProfileHash = getRuntimeDependencyProfileHash(SANDBOX_RUNTIME);
   const withSandboxSpan = (name, op, attributes, callback) => withSpan(name, op, traceContext, callback, attributes);
-  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;
@@ -8408,16 +7810,9 @@ function createSandboxSessionManager(options) {
     });
     return replacement;
   };
-  const createSandboxFromSnapshot = async (snapshotId, sandboxCredentials, emitStatus) => {
+  const createSandboxFromSnapshot = async (snapshotId, sandboxCredentials) => {
     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: {
@@ -8450,13 +7845,8 @@ function createSandboxSessionManager(options) {
     });
   };
   const createSandboxFromResolvedSnapshot = async (params) => {
-    const { runtime, snapshot, sandboxCredentials, status } = params;
+    const { runtime, snapshot, sandboxCredentials } = params;
     if (!snapshot.snapshotId) {
-      await emitSandboxStatus(
-        "fresh_runtime_boot",
-        status,
-        makeAssistantStatus("loading", "sandbox")
-      );
       return await Sandbox.create({
         timeout: timeoutMs,
         runtime,
@@ -8466,8 +7856,7 @@ function createSandboxSessionManager(options) {
     try {
       return await createSandboxFromSnapshot(
         snapshot.snapshotId,
-        sandboxCredentials,
-        status.emit
+        sandboxCredentials
       );
     } catch (error) {
       if (!isSnapshotMissingError(error)) {
@@ -8480,23 +7869,20 @@ function createSandboxSessionManager(options) {
         runtime,
         timeoutMs,
         forceRebuild: true,
-        staleSnapshotId: snapshot.snapshotId,
-        onProgress: status.reportSnapshotPhase
+        staleSnapshotId: snapshot.snapshotId
       });
       if (!rebuiltSnapshot.snapshotId) {
         throw error;
       }
       return await createSandboxFromSnapshot(
         rebuiltSnapshot.snapshotId,
-        sandboxCredentials,
-        status.emit
+        sandboxCredentials
       );
     }
   };
   const createFreshSandbox = async () => {
     const runtime = SANDBOX_RUNTIME;
     const sandboxCredentials = getVercelSandboxCredentials();
-    const status = createStatusEmitter(options?.onStatus);
     let createdSandbox;
     try {
       createdSandbox = await withSandboxSpan(
@@ -8508,22 +7894,15 @@ function createSandboxSessionManager(options) {
           "app.sandbox.runtime": runtime
         },
         async () => {
-          await emitSandboxStatus(
-            "runtime_dependency_resolve",
-            status,
-            makeAssistantStatus("loading", "sandbox runtime")
-          );
           const snapshot = await resolveRuntimeDependencySnapshot({
             runtime,
-            timeoutMs,
-            onProgress: status.reportSnapshotPhase
+            timeoutMs
           });
           setSnapshotAttributes(snapshot);
           return await createSandboxFromResolvedSnapshot({
             runtime,
             snapshot,
-            sandboxCredentials,
-            status
+            sandboxCredentials
           });
         }
       );
@@ -8837,7 +8216,6 @@ function createSandboxExecutor(options) {
     sandboxDependencyProfileHash: options?.sandboxDependencyProfileHash,
     timeoutMs: options?.timeoutMs,
     traceContext,
-    onStatus: options?.onStatus,
     onSandboxAcquired: options?.onSandboxAcquired
   });
   const withSandboxSpan = (name, op, attributes, callback) => withSpan(name, op, traceContext, callback, attributes);
@@ -9195,102 +8573,15 @@ function buildReportedProgressStatus(input) {
   if (!input || typeof input !== "object") {
     return void 0;
   }
-  const phase = input.phase;
-  if (typeof phase !== "string") {
+  const message = input.message;
+  if (typeof message !== "string") {
     return void 0;
   }
-  const detail = compactStatusText(input.detail, 40);
-  switch (phase) {
-    case "thinking":
-      return makeAssistantStatus("thinking", detail, { source: "major" });
-    case "researching":
-      return makeAssistantStatus("searching", detail, { source: "major" });
-    case "reading":
-      return makeAssistantStatus("reading", detail, { source: "major" });
-    case "executing":
-      return makeAssistantStatus("running", detail, { source: "major" });
-    case "reviewing":
-      return makeAssistantStatus("reviewing", detail, { source: "major" });
-    case "drafting":
-      return makeAssistantStatus("drafting", detail, { source: "major" });
-    default:
-      return void 0;
-  }
-}
-
-// src/chat/runtime/tool-status.ts
-function buildToolStatus(toolName, input) {
-  const obj = input && typeof input === "object" ? input : void 0;
-  const command = obj ? compactStatusCommand(obj.command) : void 0;
-  const path7 = obj ? compactStatusPath(obj.path) : void 0;
-  const filename = obj ? compactStatusFilename(obj.path) : void 0;
-  const query = obj ? compactStatusText(obj.query, 70) : void 0;
-  const domain = obj ? extractStatusUrlDomain(obj.url) : void 0;
-  const skillName = obj ? compactStatusText(obj.skill_name ?? obj.skillName, 40) : void 0;
-  const provider = obj ? compactStatusText(obj.provider, 20) : void 0;
-  const reportedProgress = buildReportedProgressStatus(obj);
-  if (toolName === "reportProgress" && reportedProgress) {
-    return reportedProgress;
-  }
-  if (command && toolName === "bash") {
-    return makeAssistantStatus("running", command);
-  }
-  if (filename && toolName === "readFile") {
-    return makeAssistantStatus("reading", filename);
-  }
-  if (filename && toolName === "writeFile") {
-    return makeAssistantStatus("updating", filename);
-  }
-  if (path7 && toolName === "writeFile") {
-    return makeAssistantStatus("updating", path7);
-  }
-  if (skillName && toolName === "loadSkill") {
-    return makeAssistantStatus("loading", skillName);
-  }
-  if (query && toolName === "webSearch") {
-    return makeAssistantStatus("searching", "sources");
-  }
-  if (query && toolName === "searchTools") {
-    return makeAssistantStatus(
-      "searching",
-      provider ? `${provider} tools` : "tools"
-    );
-  }
-  if (domain && toolName === "webFetch") {
-    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"),
-    slackCanvasRead: makeAssistantStatus("reading", "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]}`);
+  const text = message.trim();
+  if (!text) {
+    return void 0;
   }
-  const readable = toolName.replaceAll("_", " ").trim();
-  return makeAssistantStatus("running", readable || "tool");
+  return { text };
 }
 
 // src/chat/tools/execution/build-sandbox-input.ts
@@ -9441,7 +8732,12 @@ function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor
         turnId: spanContext.turnId,
         agentId: spanContext.agentId
       };
-      await onStatus?.(buildToolStatus(toolName, params));
+      if (toolName === "reportProgress") {
+        const status = buildReportedProgressStatus(params);
+        if (status) {
+          await onStatus?.(status);
+        }
+      }
       return withSpan(
         `execute_tool ${toolName}`,
         "gen_ai.execute_tool",
@@ -10344,7 +9640,6 @@ async function generateAssistantReply(messageText, context = {}) {
       sandboxId: context.sandbox?.sandboxId,
       sandboxDependencyProfileHash: context.sandbox?.sandboxDependencyProfileHash,
       traceContext: spanContext,
-      onStatus: context.onStatus,
       onSandboxAcquired: async (sandbox2) => {
         lastKnownSandboxId = sandbox2.sandboxId;
         lastKnownSandboxDependencyProfileHash = sandbox2.sandboxDependencyProfileHash;
@@ -10476,492 +9771,850 @@ async function generateAssistantReply(messageText, context = {}) {
     const syncResumeState = () => {
       loadedSkillNamesForResume = activeSkills.map((skill) => skill.name);
     };
-    const enableSkillCredentials = async (skill, reason) => {
-      if (!skill?.pluginProvider) {
-        return;
+    const enableSkillCredentials = async (skill, reason) => {
+      if (!skill?.pluginProvider) {
+        return;
+      }
+      try {
+        await capabilityRuntime.enableCredentialsForTurn({
+          activeSkill: skill,
+          reason
+        });
+      } catch (error) {
+        if (error instanceof CredentialUnavailableError && context.requester?.userId) {
+          await pluginAuth.handleCredentialUnavailable({
+            activeSkill: skill,
+            error
+          });
+        }
+        throw error;
+      }
+    };
+    setTags({
+      conversationId: spanContext.conversationId,
+      turnId: spanContext.turnId,
+      agentId: spanContext.agentId,
+      slackThreadId: context.correlation?.threadId,
+      slackUserId: context.correlation?.requesterId,
+      slackChannelId: context.correlation?.channelId,
+      runId: context.correlation?.runId,
+      assistantUserName: context.assistant?.userName,
+      modelId: botConfig.modelId
+    });
+    const tools = createTools(
+      availableSkills,
+      {
+        getGeneratedFile: (filename) => generatedFiles.find((file) => file.filename === filename),
+        onGeneratedArtifactFiles: (files) => {
+          generatedFiles.push(...files);
+        },
+        onGeneratedFiles: (files) => {
+          replyFiles.push(...files);
+        },
+        onArtifactStatePatch: async (patch) => {
+          Object.assign(artifactStatePatch, patch);
+          await context.onArtifactStateUpdated?.(
+            mergeArtifactsState(
+              context.artifactState ?? {},
+              artifactStatePatch
+            )
+          );
+        },
+        toolOverrides: context.toolOverrides,
+        onSkillLoaded: async (loadedSkill) => {
+          const resolvedSkill = await skillSandbox.loadSkill(loadedSkill.name);
+          const effective = resolvedSkill ?? loadedSkill;
+          upsertActiveSkill(activeSkills, effective);
+          syncResumeState();
+          await turnMcpToolManager.activateForSkill(effective);
+          syncResumeState();
+          if (mcpAuth.getPendingPause()) {
+            return void 0;
+          }
+          await enableSkillCredentials(
+            effective,
+            `skill:${effective.name}:turn:load`
+          );
+          if (!effective.pluginProvider) {
+            return void 0;
+          }
+          syncMcpAgentTools();
+          return {
+            available_tools: turnMcpToolManager.getActiveToolCatalog(activeSkills, {
+              provider: effective.pluginProvider
+            }).map(toExposedToolSummary)
+          };
+        }
+      },
+      {
+        channelId: context.toolChannelId ?? context.correlation?.channelId,
+        channelCapabilities: resolveChannelCapabilities(
+          context.toolChannelId ?? context.correlation?.channelId
+        ),
+        messageTs: context.correlation?.messageTs,
+        threadTs: context.correlation?.threadTs,
+        userText: userInput,
+        artifactState: context.artifactState,
+        configuration: configurationValues,
+        getActiveSkills: () => activeSkills,
+        mcpToolManager: turnMcpToolManager,
+        sandbox
+      }
+    );
+    syncResumeState();
+    for (const skill of activeSkills) {
+      await turnMcpToolManager.activateForSkill(skill);
+      syncResumeState();
+      if (mcpAuth.getPendingPause()) {
+        timeoutResumeMessages = existingCheckpoint?.piMessages ?? [];
+        throw mcpAuth.getPendingPause();
+      }
+      await enableSkillCredentials(skill, `skill:${skill.name}:turn:resume`);
+    }
+    syncResumeState();
+    const activeToolSummaries = turnMcpToolManager.getActiveToolCatalog(activeSkills).map(toExposedToolSummary);
+    baseInstructions = buildSystemPrompt({
+      availableSkills,
+      activeSkills,
+      activeTools: activeToolSummaries,
+      invocation: skillInvocation,
+      assistant: context.assistant,
+      requester: context.requester,
+      artifactState: context.artifactState,
+      configuration: configurationValues,
+      relevantConfigurationKeys: collectRelevantConfigurationKeys(
+        activeSkills,
+        invokedSkill
+      ),
+      runtimeMetadata: getRuntimeMetadata(),
+      threadParticipants: context.threadParticipants
+    });
+    const userContentParts = [{ type: "text", text: userTurnText }];
+    const omittedImageAttachmentCount = context.omittedImageAttachmentCount ?? 0;
+    if (omittedImageAttachmentCount > 0) {
+      userContentParts.push({
+        type: "text",
+        text: buildOmittedImageAttachmentNotice(omittedImageAttachmentCount)
+      });
+    }
+    for (const attachment of context.userAttachments ?? []) {
+      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(promptAttachment)
+        });
+      }
+    }
+    const inputMessagesAttribute = serializeGenAiAttribute([
+      {
+        role: "system",
+        content: [{ type: "text", text: baseInstructions }]
+      },
+      {
+        role: "user",
+        content: userContentParts.map((part) => toObservablePromptPart(part))
+      }
+    ]);
+    const agentToolHooks = {
+      onToolCall: (toolName) => {
+        toolCalls.push(toolName);
+        Promise.resolve(context.onToolCall?.(toolName)).catch((error) => {
+          logWarn(
+            "streaming_tool_call_error",
+            {},
+            {
+              "error.message": error instanceof Error ? error.message : String(error),
+              "gen_ai.tool.name": toolName
+            },
+            "Failed to deliver tool call event to stream coordinator"
+          );
+        });
+      }
+    };
+    const baseAgentTools = createAgentTools(
+      tools,
+      skillSandbox,
+      spanContext,
+      context.onStatus,
+      sandboxExecutor,
+      capabilityRuntime,
+      pluginAuth,
+      agentToolHooks
+    );
+    const agentTools = [...baseAgentTools];
+    const syncMcpAgentTools = () => {
+      const mcpTools = turnMcpToolManager.getResolvedActiveTools(activeSkills);
+      const mcpDefs = mcpToolsToDefinitions(mcpTools);
+      const mcpAgentTools = createAgentTools(
+        mcpDefs,
+        skillSandbox,
+        spanContext,
+        context.onStatus,
+        sandboxExecutor,
+        capabilityRuntime,
+        pluginAuth,
+        agentToolHooks
+      );
+      agentTools.length = 0;
+      agentTools.push(...baseAgentTools, ...mcpAgentTools);
+    };
+    syncMcpAgentTools();
+    agent = new Agent({
+      getApiKey: () => getPiGatewayApiKeyOverride(),
+      initialState: {
+        systemPrompt: baseInstructions,
+        model: resolveGatewayModel(botConfig.modelId),
+        tools: agentTools
       }
-      try {
-        await capabilityRuntime.enableCredentialsForTurn({
-          activeSkill: skill,
-          reason
+    });
+    let hasEmittedText = false;
+    let needsSeparator = false;
+    const unsubscribe = agent.subscribe((event) => {
+      if (event.type === "message_start") {
+        Promise.resolve(context.onAssistantMessageStart?.()).catch((error) => {
+          logWarn(
+            "streaming_message_start_error",
+            {},
+            {
+              "error.message": error instanceof Error ? error.message : String(error)
+            },
+            "Failed to deliver assistant message start to stream coordinator"
+          );
         });
-      } catch (error) {
-        if (error instanceof CredentialUnavailableError && context.requester?.userId) {
-          await pluginAuth.handleCredentialUnavailable({
-            activeSkill: skill,
-            error
-          });
+        if (hasEmittedText) {
+          needsSeparator = true;
         }
-        throw error;
+        return;
       }
-    };
-    setTags({
-      conversationId: spanContext.conversationId,
-      turnId: spanContext.turnId,
-      agentId: spanContext.agentId,
-      slackThreadId: context.correlation?.threadId,
-      slackUserId: context.correlation?.requesterId,
-      slackChannelId: context.correlation?.channelId,
-      runId: context.correlation?.runId,
-      assistantUserName: context.assistant?.userName,
-      modelId: botConfig.modelId
+      if (event.type !== "message_update") return;
+      if (event.assistantMessageEvent.type !== "text_delta") return;
+      const deltaText = event.assistantMessageEvent.delta;
+      if (!deltaText) return;
+      const text = needsSeparator ? "\n\n" + deltaText : deltaText;
+      needsSeparator = false;
+      hasEmittedText = true;
+      Promise.resolve(context.onTextDelta?.(text)).catch((error) => {
+        logWarn(
+          "streaming_text_delta_error",
+          {},
+          {
+            "error.message": error instanceof Error ? error.message : String(error)
+          },
+          "Failed to deliver text delta to stream"
+        );
+      });
     });
-    const tools = createTools(
-      availableSkills,
-      {
-        getGeneratedFile: (filename) => generatedFiles.find((file) => file.filename === filename),
-        onGeneratedArtifactFiles: (files) => {
-          generatedFiles.push(...files);
-        },
-        onGeneratedFiles: (files) => {
-          replyFiles.push(...files);
-        },
-        onArtifactStatePatch: async (patch) => {
-          Object.assign(artifactStatePatch, patch);
-          await context.onArtifactStateUpdated?.(
-            mergeArtifactsState(
-              context.artifactState ?? {},
-              artifactStatePatch
-            )
-          );
-        },
-        toolOverrides: context.toolOverrides,
-        onSkillLoaded: async (loadedSkill) => {
-          const resolvedSkill = await skillSandbox.loadSkill(loadedSkill.name);
-          const effective = resolvedSkill ?? loadedSkill;
-          upsertActiveSkill(activeSkills, effective);
-          syncResumeState();
-          await turnMcpToolManager.activateForSkill(effective);
-          syncResumeState();
-          if (mcpAuth.getPendingPause()) {
-            return void 0;
+    let beforeMessageCount = agent.state.messages.length;
+    let newMessages = [];
+    let completedAssistantTurn = false;
+    try {
+      if (resumedFromCheckpoint) {
+        agent.replaceMessages(existingCheckpoint.piMessages);
+      }
+      beforeMessageCount = agent.state.messages.length;
+      await withSpan(
+        "ai.generate_assistant_reply",
+        "gen_ai.invoke_agent",
+        spanContext,
+        async () => {
+          let promptResult;
+          const promptPromise = resumedFromCheckpoint ? (
+            // Checkpoint resumes continue from the persisted Pi message
+            // state. Any reconstructed replyContext only matters when the
+            // turn parked before the initial user prompt was recorded.
+            agent.continue()
+          ) : agent.prompt({
+            role: "user",
+            content: userContentParts,
+            timestamp: Date.now()
+          });
+          let timeoutId;
+          const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(() => {
+              timedOut = true;
+              agent.abort();
+              reject(
+                new Error(
+                  `Agent turn timed out after ${botConfig.turnTimeoutMs}ms`
+                )
+              );
+            }, botConfig.turnTimeoutMs);
+          });
+          try {
+            promptResult = await Promise.race([promptPromise, timeoutPromise]);
+          } catch (error) {
+            if (timedOut) {
+              logWarn(
+                "agent_turn_timeout",
+                {},
+                {
+                  "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
+                  "gen_ai.operation.name": "invoke_agent",
+                  "gen_ai.request.model": botConfig.modelId,
+                  "app.ai.turn_timeout_ms": botConfig.turnTimeoutMs
+                },
+                "Agent turn timed out and was aborted"
+              );
+              await promptPromise.catch(() => {
+              });
+              timeoutResumeMessages = [...agent.state.messages];
+            }
+            if (getPendingAuthPause()) {
+              timeoutResumeMessages = [...agent.state.messages];
+              throw getPendingAuthPause();
+            }
+            throw error;
+          } finally {
+            if (timeoutId) {
+              clearTimeout(timeoutId);
+            }
           }
-          await enableSkillCredentials(
-            effective,
-            `skill:${effective.name}:turn:load`
-          );
-          if (!effective.pluginProvider) {
-            return void 0;
+          newMessages = agent.state.messages.slice(beforeMessageCount);
+          completedAssistantTurn = hasCompletedAssistantTurn(newMessages);
+          if (getPendingAuthPause() && !completedAssistantTurn) {
+            timeoutResumeMessages = [...agent.state.messages];
+            throw getPendingAuthPause();
           }
-          syncMcpAgentTools();
-          return {
-            available_tools: turnMcpToolManager.getActiveToolCatalog(activeSkills, {
-              provider: effective.pluginProvider
-            }).map(toExposedToolSummary)
-          };
+          const outputMessages = newMessages.filter(isAssistantMessage);
+          const outputMessagesAttribute = serializeGenAiAttribute(outputMessages);
+          const usageSummary = extractGenAiUsageSummary(
+            promptResult,
+            agent.state,
+            ...outputMessages
+          );
+          turnUsage = Object.values(usageSummary).some(
+            (value) => value !== void 0
+          ) ? usageSummary : void 0;
+          setSpanAttributes({
+            ...outputMessagesAttribute ? { "gen_ai.output.messages": outputMessagesAttribute } : {},
+            ...usageSummary.inputTokens !== void 0 ? { "gen_ai.usage.input_tokens": usageSummary.inputTokens } : {},
+            ...usageSummary.outputTokens !== void 0 ? { "gen_ai.usage.output_tokens": usageSummary.outputTokens } : {}
+          });
+        },
+        {
+          "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
+          "gen_ai.operation.name": "invoke_agent",
+          "gen_ai.request.model": botConfig.modelId,
+          ...inputMessagesAttribute ? { "gen_ai.input.messages": inputMessagesAttribute } : {}
+        }
+      );
+    } finally {
+      unsubscribe();
+    }
+    if (getPendingAuthPause() && !completedAssistantTurn) {
+      throw getPendingAuthPause();
+    }
+    if (checkpointState.canUseTurnSession && sessionConversationId && sessionId) {
+      await persistCompletedCheckpoint({
+        conversationId: sessionConversationId,
+        sessionId,
+        sliceId: currentSliceId,
+        allMessages: agent.state.messages,
+        loadedSkillNames: activeSkills.map((skill) => skill.name)
+      });
+    }
+    return buildTurnResult({
+      newMessages,
+      userInput,
+      replyFiles,
+      artifactStatePatch,
+      toolCalls,
+      sandboxId: currentSandboxExecutor.getSandboxId(),
+      sandboxDependencyProfileHash: currentSandboxExecutor.getDependencyProfileHash(),
+      durationMs: Date.now() - replyStartedAtMs,
+      generatedFileCount: generatedFiles.length,
+      shouldTrace,
+      spanContext,
+      usage: turnUsage,
+      correlation: context.correlation,
+      assistantUserName: context.assistant?.userName
+    });
+  } catch (error) {
+    if (timedOut && timeoutResumeConversationId && timeoutResumeSessionId) {
+      const checkpoint = await persistTimeoutCheckpoint({
+        conversationId: timeoutResumeConversationId,
+        sessionId: timeoutResumeSessionId,
+        currentSliceId: timeoutResumeSliceId,
+        messages: timeoutResumeMessages,
+        loadedSkillNames: loadedSkillNamesForResume,
+        errorMessage: error instanceof Error ? error.message : String(error),
+        logContext: {
+          threadId: context.correlation?.threadId,
+          requesterId: context.correlation?.requesterId,
+          channelId: context.correlation?.channelId,
+          runId: context.correlation?.runId,
+          assistantUserName: context.assistant?.userName,
+          modelId: botConfig.modelId
+        }
+      });
+      if (checkpoint) {
+        throw new RetryableTurnError(
+          "turn_timeout_resume",
+          `conversation=${timeoutResumeConversationId} session=${timeoutResumeSessionId} slice=${checkpoint.sliceId} version=${checkpoint.checkpointVersion}`,
+          {
+            conversationId: timeoutResumeConversationId,
+            sessionId: timeoutResumeSessionId,
+            sliceId: checkpoint.sliceId,
+            checkpointVersion: checkpoint.checkpointVersion
+          }
+        );
+      }
+    }
+    if ((error instanceof McpAuthorizationPauseError || error instanceof PluginAuthorizationPauseError) && timeoutResumeConversationId && timeoutResumeSessionId) {
+      const nextSliceId = await persistAuthPauseCheckpoint({
+        conversationId: timeoutResumeConversationId,
+        sessionId: timeoutResumeSessionId,
+        currentSliceId: timeoutResumeSliceId,
+        messages: timeoutResumeMessages,
+        loadedSkillNames: loadedSkillNamesForResume,
+        errorMessage: error.message,
+        logContext: {
+          threadId: context.correlation?.threadId,
+          requesterId: context.correlation?.requesterId,
+          channelId: context.correlation?.channelId,
+          runId: context.correlation?.runId,
+          assistantUserName: context.assistant?.userName,
+          modelId: botConfig.modelId
         }
-      },
+      });
+      throw new RetryableTurnError(
+        error instanceof PluginAuthorizationPauseError ? "plugin_auth_resume" : "mcp_auth_resume",
+        `conversation=${timeoutResumeConversationId} session=${timeoutResumeSessionId} slice=${nextSliceId}`,
+        {
+          conversationId: timeoutResumeConversationId,
+          sessionId: timeoutResumeSessionId,
+          sliceId: nextSliceId
+        }
+      );
+    }
+    if (isRetryableTurnError(error)) {
+      throw error;
+    }
+    logException(
+      error,
+      "assistant_reply_generation_failed",
       {
-        channelId: context.toolChannelId ?? context.correlation?.channelId,
-        channelCapabilities: resolveChannelCapabilities(
-          context.toolChannelId ?? context.correlation?.channelId
-        ),
-        messageTs: context.correlation?.messageTs,
-        threadTs: context.correlation?.threadTs,
-        userText: userInput,
-        artifactState: context.artifactState,
-        configuration: configurationValues,
-        getActiveSkills: () => activeSkills,
-        mcpToolManager: turnMcpToolManager,
-        sandbox
-      }
+        slackThreadId: context.correlation?.threadId,
+        slackUserId: context.correlation?.requesterId,
+        slackChannelId: context.correlation?.channelId,
+        runId: context.correlation?.runId,
+        assistantUserName: context.assistant?.userName,
+        modelId: botConfig.modelId
+      },
+      {},
+      "generateAssistantReply failed"
     );
-    syncResumeState();
-    for (const skill of activeSkills) {
-      await turnMcpToolManager.activateForSkill(skill);
-      syncResumeState();
-      if (mcpAuth.getPendingPause()) {
-        timeoutResumeMessages = existingCheckpoint?.piMessages ?? [];
-        throw mcpAuth.getPendingPause();
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      text: `Error: ${message}`,
+      ...getSandboxMetadata(),
+      diagnostics: {
+        outcome: "provider_error",
+        modelId: botConfig.modelId,
+        assistantMessageCount: 0,
+        toolCalls: [],
+        toolResultCount: 0,
+        toolErrorCount: 0,
+        usedPrimaryText: false,
+        durationMs: Date.now() - replyStartedAtMs,
+        errorMessage: message,
+        providerError: error
       }
-      await enableSkillCredentials(skill, `skill:${skill.name}:turn:resume`);
+    };
+  } finally {
+    try {
+      await mcpToolManager?.close();
+    } catch (closeError) {
+      logWarn(
+        "mcp_tool_manager_close_failed",
+        {},
+        {
+          "error.message": closeError instanceof Error ? closeError.message : String(closeError)
+        },
+        "Failed to close MCP tool manager"
+      );
     }
-    syncResumeState();
-    const activeToolSummaries = turnMcpToolManager.getActiveToolCatalog(activeSkills).map(toExposedToolSummary);
-    baseInstructions = buildSystemPrompt({
-      availableSkills,
-      activeSkills,
-      activeTools: activeToolSummaries,
-      invocation: skillInvocation,
-      assistant: context.assistant,
-      requester: context.requester,
-      artifactState: context.artifactState,
-      configuration: configurationValues,
-      relevantConfigurationKeys: collectRelevantConfigurationKeys(
-        activeSkills,
-        invokedSkill
-      ),
-      runtimeMetadata: getRuntimeMetadata(),
-      threadParticipants: context.threadParticipants
+  }
+}
+
+// src/chat/slack/assistant-thread/status-render.ts
+var DEFAULT_STATUS_CONTEXTS = {
+  thinking: "\u2026",
+  searching: "sources",
+  reading: "task",
+  reviewing: "results",
+  drafting: "reply",
+  running: "tasks"
+};
+function formatAssistantStatusText(verb, context) {
+  const normalizedVerb = normalizeSlackStatusText(verb).trim().toLowerCase();
+  const normalizedContext = normalizeSlackStatusText(context ?? "") || DEFAULT_STATUS_CONTEXTS[normalizedVerb] || "";
+  if (!normalizedVerb) {
+    return truncateStatusText(normalizedContext || "Working");
+  }
+  const displayVerb = `${normalizedVerb[0]?.toUpperCase() ?? ""}${normalizedVerb.slice(1)}`;
+  return truncateStatusText(
+    normalizedContext ? `${displayVerb} ${normalizedContext}` : displayVerb
+  );
+}
+function makeAssistantStatus(verb, context) {
+  return {
+    text: formatAssistantStatusText(verb, context)
+  };
+}
+function renderAssistantStatus(args) {
+  const visible = truncateStatusText(
+    normalizeSlackStatusText(args.status.text)
+  );
+  return {
+    key: visible,
+    visible
+  };
+}
+function selectAssistantLoadingMessages(args) {
+  const random = args.random ?? Math.random;
+  const normalized = Array.from(
+    new Set(
+      args.messages.map((message) => truncateStatusText(normalizeSlackStatusText(message))).filter((message) => message.length > 0)
+    )
+  );
+  if (normalized.length === 0) {
+    return void 0;
+  }
+  const shuffled = [...normalized];
+  for (let index = shuffled.length - 1; index > 0; index -= 1) {
+    const otherIndex = Math.floor(random() * (index + 1));
+    [shuffled[index], shuffled[otherIndex]] = [
+      shuffled[otherIndex],
+      shuffled[index]
+    ];
+  }
+  return shuffled.slice(0, 10);
+}
+
+// src/chat/slack/assistant-thread/status-scheduler.ts
+var STATUS_UPDATE_DEBOUNCE_MS = 1e3;
+var STATUS_MIN_VISIBLE_MS = 1200;
+var STATUS_ROTATION_INTERVAL_MS = 3e4;
+function createAssistantStatusScheduler(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;
+  const loadingMessages = selectAssistantLoadingMessages({
+    messages: args.loadingMessages ?? [],
+    random
+  });
+  const defaultStatus = makeAssistantStatus("thinking");
+  let active = false;
+  let currentKey = "";
+  let currentVisibleStatus = "";
+  let currentLoadingMessages;
+  let lastStatusAt = 0;
+  let pendingStatus = null;
+  let pendingKey = "";
+  let pendingTimer = null;
+  let rotationTimer = null;
+  let inflightStatusUpdate = Promise.resolve();
+  const enqueueStatusUpdate = (task) => {
+    const request = inflightStatusUpdate.catch(() => void 0).then(async () => {
+      await task();
     });
-    const userContentParts = [{ type: "text", text: userTurnText }];
-    const omittedImageAttachmentCount = context.omittedImageAttachmentCount ?? 0;
-    if (omittedImageAttachmentCount > 0) {
-      userContentParts.push({
-        type: "text",
-        text: buildOmittedImageAttachmentNotice(omittedImageAttachmentCount)
-      });
+    inflightStatusUpdate = request.catch(() => void 0);
+    return request;
+  };
+  const scheduleRotation = () => {
+    if (rotationTimer) {
+      clearTimer(rotationTimer);
+      rotationTimer = null;
     }
-    for (const attachment of context.userAttachments ?? []) {
-      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(promptAttachment)
-        });
+    if (!active || !currentVisibleStatus) {
+      return;
+    }
+    rotationTimer = setTimer(() => {
+      rotationTimer = null;
+      if (!active || !currentVisibleStatus) {
+        return;
       }
+      void postStatus(currentVisibleStatus, currentLoadingMessages);
+    }, STATUS_ROTATION_INTERVAL_MS);
+  };
+  const getLoadingMessagesForVisibleStatus = (visible) => visible ? [visible] : void 0;
+  const getInitialStatusText = () => {
+    if (loadingMessages?.length) {
+      return loadingMessages[0];
+    }
+    return defaultStatus.text;
+  };
+  const haveSameLoadingMessages = (left, right) => {
+    if (left === right) {
+      return true;
+    }
+    if (!left || !right || left.length !== right.length) {
+      return false;
+    }
+    return left.every((message, index) => message === right[index]);
+  };
+  const postStatus = async (text, nextLoadingMessages) => {
+    if (!text && !currentVisibleStatus) {
+      return;
+    }
+    currentVisibleStatus = text;
+    currentLoadingMessages = nextLoadingMessages;
+    lastStatusAt = now();
+    scheduleRotation();
+    await enqueueStatusUpdate(async () => {
+      await args.sendStatus(text, nextLoadingMessages);
+    });
+  };
+  const postRenderedStatus = async (status) => {
+    const presentation = renderAssistantStatus({
+      status
+    });
+    const nextLoadingMessages = getLoadingMessagesForVisibleStatus(
+      presentation.visible
+    );
+    currentKey = presentation.key;
+    await postStatus(presentation.visible, nextLoadingMessages);
+  };
+  const clearPending = () => {
+    if (pendingTimer) {
+      clearTimer(pendingTimer);
+      pendingTimer = null;
     }
-    const inputMessagesAttribute = serializeGenAiAttribute([
-      {
-        role: "system",
-        content: [{ type: "text", text: baseInstructions }]
-      },
-      {
-        role: "user",
-        content: userContentParts.map((part) => toObservablePromptPart(part))
+    pendingStatus = null;
+    pendingKey = "";
+  };
+  const flushPending = async () => {
+    if (!active || !pendingStatus) {
+      clearPending();
+      return;
+    }
+    const next = pendingStatus;
+    clearPending();
+    const nextPresentation = renderAssistantStatus({
+      status: next
+    });
+    if (nextPresentation.key !== currentKey) {
+      await postRenderedStatus(next);
+    }
+  };
+  return {
+    start() {
+      active = true;
+      clearPending();
+      currentKey = "initial";
+      void postStatus(getInitialStatusText(), loadingMessages);
+    },
+    async stop() {
+      active = false;
+      clearPending();
+      if (rotationTimer) {
+        clearTimer(rotationTimer);
+        rotationTimer = null;
       }
-    ]);
-    const agentToolHooks = {
-      onToolCall: (toolName) => {
-        toolCalls.push(toolName);
-        Promise.resolve(context.onToolCall?.(toolName)).catch((error) => {
-          logWarn(
-            "streaming_tool_call_error",
-            {},
-            {
-              "error.message": error instanceof Error ? error.message : String(error),
-              "gen_ai.tool.name": toolName
-            },
-            "Failed to deliver tool call event to stream coordinator"
-          );
-        });
+      currentKey = "";
+      await postStatus("");
+    },
+    update(status) {
+      if (!active) {
+        return;
       }
-    };
-    const baseAgentTools = createAgentTools(
-      tools,
-      skillSandbox,
-      spanContext,
-      context.onStatus,
-      sandboxExecutor,
-      capabilityRuntime,
-      pluginAuth,
-      agentToolHooks
-    );
-    const agentTools = [...baseAgentTools];
-    const syncMcpAgentTools = () => {
-      const mcpTools = turnMcpToolManager.getResolvedActiveTools(activeSkills);
-      const mcpDefs = mcpToolsToDefinitions(mcpTools);
-      const mcpAgentTools = createAgentTools(
-        mcpDefs,
-        skillSandbox,
-        spanContext,
-        context.onStatus,
-        sandboxExecutor,
-        capabilityRuntime,
-        pluginAuth,
-        agentToolHooks
-      );
-      agentTools.length = 0;
-      agentTools.push(...baseAgentTools, ...mcpAgentTools);
-    };
-    syncMcpAgentTools();
-    agent = new Agent({
-      getApiKey: () => getPiGatewayApiKeyOverride(),
-      initialState: {
-        systemPrompt: baseInstructions,
-        model: resolveGatewayModel(botConfig.modelId),
-        tools: agentTools
+      const presentation = renderAssistantStatus({
+        status
+      });
+      if (!presentation.visible) {
+        return;
       }
-    });
-    let hasEmittedText = false;
-    let needsSeparator = false;
-    const unsubscribe = agent.subscribe((event) => {
-      if (event.type === "message_start") {
-        Promise.resolve(context.onAssistantMessageStart?.()).catch((error) => {
-          logWarn(
-            "streaming_message_start_error",
-            {},
-            {
-              "error.message": error instanceof Error ? error.message : String(error)
-            },
-            "Failed to deliver assistant message start to stream coordinator"
-          );
-        });
-        if (hasEmittedText) {
-          needsSeparator = true;
-        }
+      if (presentation.key === currentKey || presentation.key === pendingKey) {
         return;
       }
-      if (event.type !== "message_update") return;
-      if (event.assistantMessageEvent.type !== "text_delta") return;
-      const deltaText = event.assistantMessageEvent.delta;
-      if (!deltaText) return;
-      const text = needsSeparator ? "\n\n" + deltaText : deltaText;
-      needsSeparator = false;
-      hasEmittedText = true;
-      Promise.resolve(context.onTextDelta?.(text)).catch((error) => {
-        logWarn(
-          "streaming_text_delta_error",
-          {},
-          {
-            "error.message": error instanceof Error ? error.message : String(error)
-          },
-          "Failed to deliver text delta to stream"
+      if (presentation.visible === currentVisibleStatus) {
+        clearPending();
+        currentKey = presentation.key;
+        const nextLoadingMessages = getLoadingMessagesForVisibleStatus(
+          presentation.visible
         );
-      });
-    });
-    let beforeMessageCount = agent.state.messages.length;
-    let newMessages = [];
-    let completedAssistantTurn = false;
-    try {
-      if (resumedFromCheckpoint) {
-        agent.replaceMessages(existingCheckpoint.piMessages);
+        if (!haveSameLoadingMessages(currentLoadingMessages, nextLoadingMessages)) {
+          void postStatus(presentation.visible, nextLoadingMessages);
+        }
+        return;
       }
-      beforeMessageCount = agent.state.messages.length;
-      await withSpan(
-        "ai.generate_assistant_reply",
-        "gen_ai.invoke_agent",
-        spanContext,
-        async () => {
-          let promptResult;
-          const promptPromise = resumedFromCheckpoint ? (
-            // Checkpoint resumes continue from the persisted Pi message
-            // state. Any reconstructed replyContext only matters when the
-            // turn parked before the initial user prompt was recorded.
-            agent.continue()
-          ) : agent.prompt({
-            role: "user",
-            content: userContentParts,
-            timestamp: Date.now()
-          });
-          let timeoutId;
-          const timeoutPromise = new Promise((_, reject) => {
-            timeoutId = setTimeout(() => {
-              timedOut = true;
-              agent.abort();
-              reject(
-                new Error(
-                  `Agent turn timed out after ${botConfig.turnTimeoutMs}ms`
-                )
-              );
-            }, botConfig.turnTimeoutMs);
-          });
-          try {
-            promptResult = await Promise.race([promptPromise, timeoutPromise]);
-          } catch (error) {
-            if (timedOut) {
-              logWarn(
-                "agent_turn_timeout",
-                {},
-                {
-                  "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
-                  "gen_ai.operation.name": "invoke_agent",
-                  "gen_ai.request.model": botConfig.modelId,
-                  "app.ai.turn_timeout_ms": botConfig.turnTimeoutMs
-                },
-                "Agent turn timed out and was aborted"
-              );
-              await promptPromise.catch(() => {
-              });
-              timeoutResumeMessages = [...agent.state.messages];
-            }
-            if (getPendingAuthPause()) {
-              timeoutResumeMessages = [...agent.state.messages];
-              throw getPendingAuthPause();
-            }
-            throw error;
-          } finally {
-            if (timeoutId) {
-              clearTimeout(timeoutId);
-            }
-          }
-          newMessages = agent.state.messages.slice(beforeMessageCount);
-          completedAssistantTurn = hasCompletedAssistantTurn(newMessages);
-          if (getPendingAuthPause() && !completedAssistantTurn) {
-            timeoutResumeMessages = [...agent.state.messages];
-            throw getPendingAuthPause();
-          }
-          const outputMessages = newMessages.filter(isAssistantMessage);
-          const outputMessagesAttribute = serializeGenAiAttribute(outputMessages);
-          const usageSummary = extractGenAiUsageSummary(
-            promptResult,
-            agent.state,
-            ...outputMessages
-          );
-          turnUsage = Object.values(usageSummary).some(
-            (value) => value !== void 0
-          ) ? usageSummary : void 0;
-          setSpanAttributes({
-            ...outputMessagesAttribute ? { "gen_ai.output.messages": outputMessagesAttribute } : {},
-            ...usageSummary.inputTokens !== void 0 ? { "gen_ai.usage.input_tokens": usageSummary.inputTokens } : {},
-            ...usageSummary.outputTokens !== void 0 ? { "gen_ai.usage.output_tokens": usageSummary.outputTokens } : {}
-          });
+      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();
         },
-        {
-          "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
-          "gen_ai.operation.name": "invoke_agent",
-          "gen_ai.request.model": botConfig.modelId,
-          ...inputMessagesAttribute ? { "gen_ai.input.messages": inputMessagesAttribute } : {}
-        }
+        Math.max(1, waitMs)
       );
-    } finally {
-      unsubscribe();
     }
-    if (getPendingAuthPause() && !completedAssistantTurn) {
-      throw getPendingAuthPause();
+  };
+}
+
+// src/chat/slack/assistant-thread/status-send.ts
+var SLACK_ASSISTANT_ACTIVE_STATUS = "is working on your request...";
+function createSlackAdapterStatusSender(args) {
+  const adapter = args.getSlackAdapter();
+  const boundToken = getSlackAdapterRequestToken(adapter);
+  return async (text, loadingMessages) => {
+    const channelId = args.channelId;
+    const threadTs = args.threadTs;
+    if (!channelId || !threadTs) {
+      return;
     }
-    if (checkpointState.canUseTurnSession && sessionConversationId && sessionId) {
-      await persistCompletedCheckpoint({
-        conversationId: sessionConversationId,
-        sessionId,
-        sliceId: currentSliceId,
-        allMessages: agent.state.messages,
-        loadedSkillNames: activeSkills.map((skill) => skill.name)
-      });
+    const normalizedChannelId = normalizeSlackConversationId(channelId);
+    if (!normalizedChannelId) {
+      return;
     }
-    return buildTurnResult({
-      newMessages,
-      userInput,
-      replyFiles,
-      artifactStatePatch,
-      toolCalls,
-      sandboxId: currentSandboxExecutor.getSandboxId(),
-      sandboxDependencyProfileHash: currentSandboxExecutor.getDependencyProfileHash(),
-      durationMs: Date.now() - replyStartedAtMs,
-      generatedFileCount: generatedFiles.length,
-      shouldTrace,
-      spanContext,
-      usage: turnUsage,
-      correlation: context.correlation,
-      assistantUserName: context.assistant?.userName
-    });
-  } catch (error) {
-    if (timedOut && timeoutResumeConversationId && timeoutResumeSessionId) {
-      const checkpoint = await persistTimeoutCheckpoint({
-        conversationId: timeoutResumeConversationId,
-        sessionId: timeoutResumeSessionId,
-        currentSliceId: timeoutResumeSliceId,
-        messages: timeoutResumeMessages,
-        loadedSkillNames: loadedSkillNamesForResume,
-        errorMessage: error instanceof Error ? error.message : String(error),
-        logContext: {
-          threadId: context.correlation?.threadId,
-          requesterId: context.correlation?.requesterId,
-          channelId: context.correlation?.channelId,
-          runId: context.correlation?.runId,
-          assistantUserName: context.assistant?.userName,
-          modelId: botConfig.modelId
-        }
+    const nextLoadingMessages = text ? loadingMessages ?? [text] : void 0;
+    try {
+      await runWithBoundSlackToken(
+        adapter,
+        boundToken,
+        () => adapter.setAssistantStatus(
+          normalizedChannelId,
+          threadTs,
+          text ? SLACK_ASSISTANT_ACTIVE_STATUS : "",
+          nextLoadingMessages
+        )
+      );
+    } catch (error) {
+      logAssistantStatusFailure({
+        status: text,
+        error,
+        channelId,
+        normalizedChannelId,
+        threadTs
       });
-      if (checkpoint) {
-        throw new RetryableTurnError(
-          "turn_timeout_resume",
-          `conversation=${timeoutResumeConversationId} session=${timeoutResumeSessionId} slice=${checkpoint.sliceId} version=${checkpoint.checkpointVersion}`,
-          {
-            conversationId: timeoutResumeConversationId,
-            sessionId: timeoutResumeSessionId,
-            sliceId: checkpoint.sliceId,
-            checkpointVersion: checkpoint.checkpointVersion
-          }
-        );
-      }
     }
-    if ((error instanceof McpAuthorizationPauseError || error instanceof PluginAuthorizationPauseError) && timeoutResumeConversationId && timeoutResumeSessionId) {
-      const nextSliceId = await persistAuthPauseCheckpoint({
-        conversationId: timeoutResumeConversationId,
-        sessionId: timeoutResumeSessionId,
-        currentSliceId: timeoutResumeSliceId,
-        messages: timeoutResumeMessages,
-        loadedSkillNames: loadedSkillNamesForResume,
-        errorMessage: error.message,
-        logContext: {
-          threadId: context.correlation?.threadId,
-          requesterId: context.correlation?.requesterId,
-          channelId: context.correlation?.channelId,
-          runId: context.correlation?.runId,
-          assistantUserName: context.assistant?.userName,
-          modelId: botConfig.modelId
-        }
-      });
-      throw new RetryableTurnError(
-        error instanceof PluginAuthorizationPauseError ? "plugin_auth_resume" : "mcp_auth_resume",
-        `conversation=${timeoutResumeConversationId} session=${timeoutResumeSessionId} slice=${nextSliceId}`,
-        {
-          conversationId: timeoutResumeConversationId,
-          sessionId: timeoutResumeSessionId,
-          sliceId: nextSliceId
-        }
-      );
+  };
+}
+function createSlackWebApiStatusSender(args) {
+  const getClient2 = args.getSlackClient ?? getSlackClient;
+  return async (text, loadingMessages) => {
+    const channelId = args.channelId;
+    const threadTs = args.threadTs;
+    if (!channelId || !threadTs) {
+      return;
     }
-    if (isRetryableTurnError(error)) {
-      throw error;
+    const normalizedChannelId = normalizeSlackConversationId(channelId);
+    if (!normalizedChannelId) {
+      return;
     }
-    logException(
-      error,
-      "assistant_reply_generation_failed",
-      {
-        slackThreadId: context.correlation?.threadId,
-        slackUserId: context.correlation?.requesterId,
-        slackChannelId: context.correlation?.channelId,
-        runId: context.correlation?.runId,
-        assistantUserName: context.assistant?.userName,
-        modelId: botConfig.modelId
-      },
-      {},
-      "generateAssistantReply failed"
-    );
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      text: `Error: ${message}`,
-      ...getSandboxMetadata(),
-      diagnostics: {
-        outcome: "provider_error",
-        modelId: botConfig.modelId,
-        assistantMessageCount: 0,
-        toolCalls: [],
-        toolResultCount: 0,
-        toolErrorCount: 0,
-        usedPrimaryText: false,
-        durationMs: Date.now() - replyStartedAtMs,
-        errorMessage: message,
-        providerError: error
-      }
-    };
-  } finally {
+    const nextLoadingMessages = text ? loadingMessages ?? [text] : void 0;
     try {
-      await mcpToolManager?.close();
-    } catch (closeError) {
-      logWarn(
-        "mcp_tool_manager_close_failed",
-        {},
-        {
-          "error.message": closeError instanceof Error ? closeError.message : String(closeError)
-        },
-        "Failed to close MCP tool manager"
-      );
+      await getClient2().assistant.threads.setStatus({
+        channel_id: normalizedChannelId,
+        thread_ts: threadTs,
+        status: text ? SLACK_ASSISTANT_ACTIVE_STATUS : "",
+        ...nextLoadingMessages ? { loading_messages: nextLoadingMessages } : {}
+      });
+    } catch (error) {
+      logAssistantStatusFailure({
+        status: text,
+        error,
+        channelId,
+        normalizedChannelId,
+        threadTs
+      });
     }
+  };
+}
+function getSlackAdapterRequestToken(adapter) {
+  const token = adapter.requestContext?.getStore()?.token;
+  if (typeof token !== "string") {
+    return void 0;
+  }
+  const trimmed = token.trim();
+  return trimmed || void 0;
+}
+async function runWithBoundSlackToken(adapter, token, task) {
+  if (!token) {
+    return await task();
   }
+  return await adapter.withBotToken(token, task);
+}
+function logAssistantStatusFailure(args) {
+  logWarn(
+    "assistant_status_update_failed",
+    {},
+    {
+      "app.slack.status_text": args.status || "(clear)",
+      "app.slack.channel_id_raw": args.channelId,
+      "app.slack.channel_id": args.normalizedChannelId,
+      "app.slack.thread_ts": args.threadTs,
+      "error.message": args.error instanceof Error ? args.error.message : String(args.error)
+    },
+    `Failed to update assistant status channel=${args.normalizedChannelId} raw=${args.channelId} thread=${args.threadTs}`
+  );
+}
+
+// src/chat/slack/assistant-thread/status.ts
+function createSlackAdapterAssistantStatusSession(args) {
+  return createAssistantStatusScheduler({
+    sendStatus: createSlackAdapterStatusSender({
+      channelId: args.channelId,
+      threadTs: args.threadTs,
+      getSlackAdapter: args.getSlackAdapter
+    }),
+    loadingMessages: args.loadingMessages ?? botConfig.loadingMessages,
+    now: args.now,
+    setTimer: args.setTimer,
+    clearTimer: args.clearTimer,
+    random: args.random
+  });
+}
+function createSlackWebApiAssistantStatusSession(args) {
+  return createAssistantStatusScheduler({
+    sendStatus: createSlackWebApiStatusSender({
+      channelId: args.channelId,
+      threadTs: args.threadTs,
+      getSlackClient: args.getSlackClient
+    }),
+    loadingMessages: args.loadingMessages ?? botConfig.loadingMessages,
+    now: args.now,
+    setTimer: args.setTimer,
+    clearTimer: args.clearTimer,
+    random: args.random
+  });
 }
 
 // src/chat/slack/footer.ts