@sentry/junior 0.27.0 → 0.27.1

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.",
@@ -5193,23 +5064,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."
+      })
     })
   });
 }
@@ -7254,563 +7114,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 +7674,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 +7714,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 +7731,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 +7806,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 +7841,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 +7852,7 @@ function createSandboxSessionManager(options) {
     try {
       return await createSandboxFromSnapshot(
         snapshot.snapshotId,
-        sandboxCredentials,
-        status.emit
+        sandboxCredentials
       );
     } catch (error) {
       if (!isSnapshotMissingError(error)) {
@@ -8480,23 +7865,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 +7890,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 +8212,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 +8569,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 +8728,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 +9636,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 +9767,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