@agent-native/core 0.95.0 → 0.96.0

package/corpus/core/src/client/sse-event-processor.ts

@@ -231,12 +231,6 @@ export type PreparingActionState = {
   toolEntries?: Map<string, PreparingActionEntry>;
 };
 
-function formatProgressBytes(bytes: number): string {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-
 function activityProgressBytes(ev: SSEEvent): number | undefined {
   return typeof ev.progressBytes === "number" &&
     Number.isFinite(ev.progressBytes) &&
@@ -281,7 +275,7 @@ function preparationActivityLabel(
   if (progressBytes <= 0) {
     return `Preparing ${action}...`;
   }
-  return `Writing ${action}... (${formatProgressBytes(progressBytes)} prepared)`;
+  return `Writing ${action}...`;
 }
 
 function visibleActivityLabel(ev: SSEEvent, tool?: string): string {
@@ -301,16 +295,8 @@ function findPendingToolCallIndex(
   // calls can be in flight simultaneously, and name-only matching would
   // attach a result to the wrong call.
   if (toolCallId) {
-    for (let i = content.length - 1; i >= 0; i--) {
-      const part = content[i];
-      if (
-        part.type === "tool-call" &&
-        part.toolCallId === toolCallId &&
-        part.result === undefined
-      ) {
-        return i;
-      }
-    }
+    const exactIndex = findPendingToolCallIndexById(content, toolCallId);
+    if (exactIndex >= 0) return exactIndex;
     // Fall through to name-matching: the start event may have arrived before
     // the server started emitting ids (e.g. older server build), so the
     // stored toolCallId is the locally-generated "tc_N" value rather than the
@@ -329,6 +315,76 @@ function findPendingToolCallIndex(
   return -1;
 }
 
+function findPendingToolCallIndexById(
+  content: ContentPart[],
+  toolCallId: string,
+): number {
+  for (let i = content.length - 1; i >= 0; i--) {
+    const part = content[i];
+    if (
+      part.type === "tool-call" &&
+      part.toolCallId === toolCallId &&
+      part.result === undefined
+    ) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+function findOldestPendingActivityToolCallIndex(
+  content: ContentPart[],
+  toolName: string,
+): number {
+  for (let i = 0; i < content.length; i += 1) {
+    const part = content[i];
+    if (
+      part.type === "tool-call" &&
+      part.toolName === toolName &&
+      part.activity === true &&
+      part.result === undefined
+    ) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+function findPendingActivityToolCallIndex(
+  content: ContentPart[],
+  toolName: string,
+  toolCallId?: string,
+): number {
+  if (!toolCallId) {
+    return findPendingToolCallIndex(content, toolName);
+  }
+
+  // Activity events emitted while the model is assembling tool input already
+  // carry the engine's stable call id. Match that id exactly so repeated
+  // progress for one call updates one placeholder while parallel same-name
+  // calls retain separate cards.
+  const exactIndex = findPendingToolCallIndexById(content, toolCallId);
+  if (exactIndex >= 0) return exactIndex;
+
+  // Older activity events may omit the id before a later progress event adds
+  // it. Upgrade one unambiguous reader-local placeholder instead of painting a
+  // second card for the same logical call.
+  const readerLocalCandidates: number[] = [];
+  for (let i = 0; i < content.length; i += 1) {
+    const part = content[i];
+    if (
+      part.type === "tool-call" &&
+      part.toolName === toolName &&
+      part.activity === true &&
+      part.result === undefined &&
+      /^tc_\d+$/.test(part.toolCallId)
+    ) {
+      readerLocalCandidates.push(i);
+    }
+  }
+  return readerLocalCandidates.length === 1 ? readerLocalCandidates[0] : -1;
+}
+
 function findCompletedToolCallIndex(
   content: ContentPart[],
   toolCallId?: string,
@@ -1000,7 +1056,17 @@ export function processEvent(
     }
     if (!tool) return { action: "continue" };
 
-    const pendingToolCallIndex = findPendingToolCallIndex(content, tool);
+    const pendingToolCallIndex = findPendingActivityToolCallIndex(
+      content,
+      tool,
+      ev.id,
+    );
+    if (pendingToolCallIndex >= 0 && ev.id) {
+      const pending = content[pendingToolCallIndex];
+      if (pending?.type === "tool-call" && pending.toolCallId !== ev.id) {
+        content[pendingToolCallIndex] = { ...pending, toolCallId: ev.id };
+      }
+    }
     if (pendingToolCallIndex === -1) {
       // Only surface a placeholder spinner when this tool has no card yet. A
       // trailing activity heartbeat that arrives after the matching tool_done
@@ -1011,12 +1077,13 @@ export function processEvent(
         (part) =>
           part.type === "tool-call" &&
           part.toolName === tool &&
-          part.result !== undefined,
+          part.result !== undefined &&
+          (!ev.id || part.toolCallId === ev.id),
       );
       if (!hasCompletedSameTool) {
         content.push({
           type: "tool-call",
-          toolCallId: `tc_${++toolCallCounter.value}`,
+          toolCallId: ev.id ?? `tc_${++toolCallCounter.value}`,
           toolName: tool,
           argsText: "",
           args: {},
@@ -1054,7 +1121,9 @@ export function processEvent(
     }
     // Pass the server-assigned id so we upgrade the pending activity card
     // using id-match when available (parallel same-name calls stay separate).
-    const pendingToolCallIndex = findPendingToolCallIndex(content, tool, ev.id);
+    const pendingToolCallIndex = ev.id
+      ? findPendingActivityToolCallIndex(content, tool, ev.id)
+      : findOldestPendingActivityToolCallIndex(content, tool);
     const pendingToolCall =
       pendingToolCallIndex >= 0 ? content[pendingToolCallIndex] : undefined;
     const pendingIsActivityPlaceholder =

package/corpus/core/src/client/use-chat-threads.ts

@@ -449,8 +449,17 @@ export function useChatThreads(
           // haven't shown up in the server list yet — the server only learns
           // about a thread when the user actually sends a message and the
           // agent run's `persistSubmittedUserMessage` writes the row.
+          //
+          // Archived threads are excluded here too: the server list omits
+          // archived threads by default, so a thread we archived this same
+          // session would otherwise look identical to a not-yet-synced
+          // optimistic thread (created this session, missing from `loaded`)
+          // and get preserved forever instead of disappearing once archived.
           const optimisticOnly = prev.filter(
-            (t) => newlyCreatedRef.current.has(t.id) && !loadedIds.has(t.id),
+            (t) =>
+              newlyCreatedRef.current.has(t.id) &&
+              !loadedIds.has(t.id) &&
+              !t.archivedAt,
           );
           // Reconcile each server thread against our local copy. If the local
           // copy has a newer updatedAt or higher messageCount, keep those

package/corpus/core/src/client/voice-provider-status.ts

@@ -0,0 +1,44 @@
+import { useCallback, useEffect, useState } from "react";
+
+import { agentNativePath } from "./api-path.js";
+
+export interface VoiceProviderStatus {
+  builder: boolean;
+  openai: boolean;
+}
+
+export async function getVoiceProviderStatus(): Promise<VoiceProviderStatus> {
+  const response = await fetch(
+    agentNativePath("/_agent-native/voice-providers/status"),
+    { credentials: "same-origin" },
+  );
+  if (!response.ok) {
+    throw new Error(`Voice provider status unavailable (${response.status})`);
+  }
+  const status = (await response.json()) as Partial<VoiceProviderStatus>;
+  return { builder: status.builder === true, openai: status.openai === true };
+}
+
+export function useVoiceProviderStatus() {
+  const [status, setStatus] = useState<VoiceProviderStatus | null>(null);
+
+  const refresh = useCallback(async () => {
+    try {
+      setStatus(await getVoiceProviderStatus());
+    } catch {
+      // Keep the last known status. The session route remains authoritative.
+    }
+  }, []);
+
+  useEffect(() => {
+    void refresh();
+    window.addEventListener("focus", refresh);
+    window.addEventListener("agent-engine:configured-changed", refresh);
+    return () => {
+      window.removeEventListener("focus", refresh);
+      window.removeEventListener("agent-engine:configured-changed", refresh);
+    };
+  }, [refresh]);
+
+  return { status, refresh };
+}

package/corpus/core/src/code-agents/transcript-normalizer.ts

@@ -61,6 +61,16 @@ export interface NormalizedCodeAgentToolEvent extends NormalizedCodeAgentTranscr
    * it.  Absent on old transcript events — UI must handle both cases.
    */
   structuredMeta?: Record<string, unknown>;
+  /**
+   * Stable approval id extracted from the synthetic "Approval required..."
+   * bash result (see `requestCodeAgentApproval` in `cli/code-agent-executor.ts`)
+   * when this exact approval has not yet been resolved elsewhere in the
+   * transcript (approved / denied / allowlisted / forbidden). Consumers attach
+   * this as `approval: { approvalKey }` on the rendered tool-call content part
+   * so the shared `ApprovalAffordance` can render inline. Absent once a later
+   * transcript event records a resolution for this approval id.
+   */
+  pendingApprovalKey?: string;
 }
 
 export interface NormalizedCodeAgentStatusEvent extends NormalizedCodeAgentTranscriptBase {
@@ -70,6 +80,7 @@ export interface NormalizedCodeAgentStatusEvent extends NormalizedCodeAgentTrans
   statusKind: CodeAgentTranscriptEvent["kind"];
   status?: string;
   phase?: string;
+  signal?: CodeAgentTranscriptEvent["signal"];
   metadata?: Record<string, unknown>;
 }
 
@@ -82,6 +93,35 @@ export interface NormalizedCodeAgentThinkingEvent extends NormalizedCodeAgentTra
   text: string;
 }
 
+/** Structured signal value stamped on the "no LLM provider key" status event. */
+export const CREDENTIAL_GAP_SIGNAL: NonNullable<
+  CodeAgentTranscriptEvent["signal"]
+> = "credential-gap";
+
+/**
+ * Shared "credential gap" detection for code-agent transcript events and the
+ * normalized status items built from them. Prefers the structured `signal`
+ * field the executor stamps on the event (see `code-agent-executor.ts`); only
+ * falls back to matching the legacy hint text for transcripts persisted
+ * before the structured signal existed. Accepts either a raw
+ * `CodeAgentTranscriptEvent` (`message`) or a `NormalizedCodeAgentStatusEvent`
+ * (`text`), and any of the other UI-facing transcript event shapes that carry
+ * the same field names, so every consumer can share one implementation
+ * instead of re-implementing the regex.
+ */
+export function isCredentialGapCodeAgentEvent(event: {
+  signal?: string;
+  text?: string;
+  message?: string;
+}): boolean {
+  if (event.signal === CREDENTIAL_GAP_SIGNAL) return true;
+  return isLegacyCredentialGapHintText(event.text ?? event.message ?? "");
+}
+
+function isLegacyCredentialGapHintText(value: string): boolean {
+  return /No LLM provider key was found|Missing credentials/i.test(value);
+}
+
 export function normalizeCodeAgentTranscript(
   events: readonly CodeAgentTranscriptEvent[],
 ): NormalizedCodeAgentTranscript {
@@ -148,6 +188,7 @@ export function normalizeCodeAgentTranscript(
   hiddenEvents.sort(
     (a, b) => (eventOrder.get(a.id) ?? 0) - (eventOrder.get(b.id) ?? 0),
   );
+  applyPendingCodeAgentApprovalKeys(dedupedItems, events);
 
   return {
     items: dedupedItems,
@@ -156,6 +197,40 @@ export function normalizeCodeAgentTranscript(
   };
 }
 
+/**
+ * Stamp `pendingApprovalKey` onto completed bash tool events whose synthetic
+ * result carries an "Approval id: {id}" marker (see `requestCodeAgentApproval`
+ * in `cli/code-agent-executor.ts`), unless a later raw event already recorded
+ * a resolution for that same id (approved / denied / allowlisted-and-run /
+ * forbidden — all stamp `metadata.approvalId`).
+ *
+ * Resolution lookup scans the *raw* event stream rather than the normalized
+ * items: resolution status events are intentionally low-signal (they read as
+ * "status: running") and get folded into `hiddenEvents` by
+ * `isLowSignalLifecycleEvent`, so they would not otherwise be visible here.
+ */
+function applyPendingCodeAgentApprovalKeys(
+  items: NormalizedCodeAgentTranscriptItem[],
+  events: readonly CodeAgentTranscriptEvent[],
+): void {
+  const resolvedApprovalIds = new Set<string>();
+  for (const event of events) {
+    const approvalId = stringMetadata(event.metadata, "approvalId");
+    if (approvalId) resolvedApprovalIds.add(approvalId);
+  }
+  for (const item of items) {
+    if (item.type !== "tool" || item.state !== "completed") continue;
+    if (typeof item.result !== "string") continue;
+    const match = CODE_AGENT_APPROVAL_ID_RESULT_PATTERN.exec(item.result);
+    const id = match?.[1];
+    if (id && !resolvedApprovalIds.has(id)) {
+      item.pendingApprovalKey = id;
+    }
+  }
+}
+
+const CODE_AGENT_APPROVAL_ID_RESULT_PATTERN = /Approval id:\s*(\S+)/;
+
 function createUserTurn(
   event: CodeAgentTranscriptEvent,
   turnIndex: number,
@@ -253,6 +328,7 @@ function createStatusEvent(
     statusKind: event.kind,
     status: stringMetadata(metadata, "status"),
     phase: stringMetadata(metadata, "phase"),
+    signal: event.signal,
     metadata,
     createdAt: event.createdAt,
     updatedAt: event.createdAt,

package/corpus/core/src/connections/catalog.ts

@@ -66,9 +66,9 @@ export const WORKSPACE_CONNECTION_PROVIDERS = [
     credentialKeys: [
       {
         key: "SLACK_BOT_TOKEN",
-        label: "Slack bot token",
+        label: "Slack bot token (legacy)",
         description:
-          "Bot token with the smallest channel and history scopes needed by the template.",
+          "Legacy single-workspace fallback. For new messaging automations, connect Slack from Settings → Messaging instead.",
         required: true,
       },
     ],

package/corpus/core/src/deploy/build.ts

@@ -984,17 +984,21 @@ function isSsrHtmlOrDataResponse(headers, status, pathname) {
 /**
  * Apply the SSR cache policy to the response headers.
  *
- * SSR IS A PUBLIC, HARD-CDN-CACHED SHELL — SERVED IDENTICALLY TO EVERYONE.
- * Every SSR HTML / React Router .data response gets the same public
- * stale-while-revalidate policy for ALL visitors, authenticated or not. The SSR
- * output is impersonal (the handler never reads the request's session/cookies),
- * so it is safe to hard-cache one shared copy at the edge. Do NOT reintroduce
- * per-user / cookie-based cache variation here (no private, no no-store, no
- * "authenticated then don't cache" branch) — that makes every logged-in
- * visitor's pages uncacheable. Per-user state is resolved client-side instead.
+ * Unannotated SSR HTML and React Router .data responses share a public
+ * stale-while-revalidate cache policy. Preserve an explicit route policy,
+ * though: token-gated and personalized routes can opt out with private or
+ * no-store policies.
  */
 function applyDefaultSsrCacheHeader(headers, status, pathname) {
   if (!isSsrHtmlOrDataResponse(headers, status, pathname)) return;
+  // React Router marks every .data response as no-cache, but those loader
+  // payloads are safe to cache at the shared edge. Preserve only explicit
+  // private/no-store policies, which token-gated and personalized routes use
+  // to opt out of shared caching.
+  const cacheControl = headers.get("cache-control")?.toLowerCase() ?? "";
+  if (cacheControl.includes("private") || cacheControl.includes("no-store")) {
+    return;
+  }
 
   headers.set("cache-control", DEFAULT_SSR_CACHE_CONTROL);
   headers.set("cdn-cache-control", DEFAULT_SSR_CDN_CACHE_CONTROL);

package/corpus/core/src/integrations/a2a-continuation-processor.ts

@@ -4,6 +4,7 @@ import type { Task } from "../a2a/types.js";
 import {
   formatLlmCredentialErrorMessage,
   isLlmCredentialError,
+  LLM_MISSING_CREDENTIALS_ERROR_CODE,
 } from "../agent/engine/credential-errors.js";
 import { withConfiguredAppBasePath } from "../server/app-base-path.js";
 import { FRAMEWORK_ROUTE_PREFIX } from "../server/core-routes-plugin.js";
@@ -457,15 +458,44 @@ function formatContinuationFailureMessage(
   continuation: A2AContinuation,
   reason: string,
 ): string {
-  if (isLlmCredentialError(reason)) {
-    return formatLlmCredentialErrorMessage({
-      agentName: continuation.agentName,
-    });
+  const explicitCode = extractFailureCode(reason);
+  const diagnostics = formatContinuationFailureDiagnostics(
+    continuation,
+    reason,
+  );
+  if (isLlmCredentialError(reason, explicitCode)) {
+    return (
+      formatLlmCredentialErrorMessage({
+        agentName: continuation.agentName,
+      }) + diagnostics
+    );
   }
 
   return `The ${continuation.agentName} agent could not finish this request: ${sanitizeFailureReason(
     reason,
-  )}`;
+  )}${diagnostics}`;
+}
+
+function formatContinuationFailureDiagnostics(
+  continuation: A2AContinuation,
+  reason: string,
+): string {
+  return `\n\nError code: \`${continuationFailureCode(reason)}\`\nRequest ID: \`${continuation.integrationTaskId}\`\nContinuation ID: \`${continuation.id}\`\nDownstream task ID: \`${continuation.a2aTaskId}\``;
+}
+
+function continuationFailureCode(reason: string): string {
+  const explicitCode = extractFailureCode(reason);
+  if (explicitCode) return explicitCode;
+  if (isLlmCredentialError(reason, explicitCode)) {
+    return LLM_MISSING_CREDENTIALS_ERROR_CODE;
+  }
+  if (/\btimed out polling\b/i.test(reason)) return "a2a_remote_timeout";
+  return "a2a_downstream_error";
+}
+
+function extractFailureCode(reason: string): string | null {
+  const match = /\bcode\s*[:=]\s*[`"']?([a-z][a-z0-9_]{0,79})\b/i.exec(reason);
+  return match?.[1]?.toLowerCase() ?? null;
 }
 
 function isRemoteWorkExpired(continuation: A2AContinuation): boolean {

package/corpus/core/src/integrations/adapters/slack.ts

@@ -37,6 +37,7 @@ const SLACK_API_TIMEOUT_MS = 10_000;
 const SLACK_PERMALINK_TIMEOUT_MS = 1_000;
 const SLACK_CONTEXT_MESSAGE_LIMIT = 15;
 const SLACK_CONTEXT_TEXT_LIMIT = 2_000;
+const SLACK_CALM_PROGRESS_THRESHOLD_SECONDS = 30;
 
 export interface SlackAdapterOptions {
   /** Resolve the bot token for the exact Slack installation. */
@@ -323,12 +324,10 @@ export function slackAdapter(
     async postProcessingPlaceholder(
       incoming: IncomingMessage,
     ): Promise<{ placeholderRef: string } | null> {
-      // No placeholder reply in the thread — Slack's native assistant
-      // status bar ("agent-native is thinking…", below the composer) is the
-      // loading affordance. A second visible "Working on it…" reply was
-      // redundant and added an extra chunk that we then had to overwrite.
-      // We just set the native status and return null so sendResponse posts
-      // the final reply as a fresh message.
+      // No placeholder reply in the thread — Slack's native assistant status
+      // bar and the task stream are the loading affordance. Keep the status
+      // specific about intent instead of presenting the generic thinking
+      // state while the native plan is opening.
       const token = await resolveBotToken(incoming);
       if (!token) return null;
 
@@ -336,11 +335,16 @@ export function slackAdapter(
       const threadTs = incoming.platformContext.threadTs as string;
       if (!channelId || !threadTs) return null;
 
-      // Best-effort: flip the native Agent "is thinking…" status bar in the
+      // Best-effort: flip the native Agent status bar in the
       // channel input area. Slack accepts chat:write for this method. The
       // canonical manifest separately requests assistant:write for Agent View
       // and app_context_changed events.
-      setSlackAssistantStatus(token, channelId, threadTs, "is thinking…");
+      setSlackAssistantStatus(
+        token,
+        channelId,
+        threadTs,
+        "I’m looking into this now…",
+      );
       return null;
     },
 
@@ -1266,6 +1270,42 @@ function shortTaskTitle(value: unknown): string {
   return text.replace(/[-_]/g, " ").slice(0, 200);
 }
 
+function delegatedTaskTitle(agent: unknown): string {
+  return `Contact ${shortTaskTitle(agent)}`;
+}
+
+function formatElapsedSeconds(elapsedSeconds: number): string {
+  const totalSeconds = Math.max(0, Math.round(elapsedSeconds));
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+}
+
+function formatProgressState(state: string): string {
+  if (state === "submitted") return "Queued";
+  if (state === "working") return "Working";
+  return shortTaskTitle(state);
+}
+
+function delegatedProgressDetails(
+  agent: unknown,
+  state: string,
+  elapsedSeconds: number,
+  detail?: string,
+): string {
+  const elapsed = formatElapsedSeconds(elapsedSeconds);
+  const progress = `${formatProgressState(state)} · ${elapsed}`;
+  const update = detail ? shortTaskTitle(detail) : "";
+
+  if (elapsedSeconds >= SLACK_CALM_PROGRESS_THRESHOLD_SECONDS) {
+    const agentName = shortTaskTitle(agent);
+    const context = update ? ` — ${update}.` : ".";
+    return `${progress}${context} This is taking longer than usual, but ${agentName} is still working. I’ll post the result here.`;
+  }
+
+  return update ? `${progress} — ${update}` : progress;
+}
+
 async function postSlackJson(
   token: string,
   method: string,
@@ -1315,18 +1355,18 @@ async function startSlackRunProgress(
       ...(incoming.tenantId ? { recipient_team_id: incoming.tenantId } : {}),
       ...(incoming.senderId ? { recipient_user_id: incoming.senderId } : {}),
       task_display_mode: "plan",
-      markdown_text: "Working on your request…",
+      markdown_text: "I’m looking into this for you.",
       chunks: [
         {
           type: "plan_update",
-          title: "Working on your request",
+          title: "I’m looking into this for you",
         },
         {
           type: "task_update",
           id: "agent-native:context",
-          title: "Understand the request",
+          title: "Review the request",
           status: "in_progress",
-          details: "Loading relevant context",
+          details: "Finding the information needed for an answer",
         },
       ],
     });
@@ -1373,7 +1413,7 @@ function createSlackRunProgress(
   const toolTaskIds = new Map<string, string>();
   const agentTaskIds = new Map<string, string>();
   tasks.set("agent-native:context", {
-    title: "Understand the request",
+    title: "Review the request",
     status: "in_progress",
   });
   let sequence = 0;
@@ -1540,9 +1580,19 @@ function createSlackRunProgress(
             : event.status === "done"
               ? "complete"
               : "error";
-        const title = `Ask ${shortTaskTitle(event.agent)}`;
+        const title = delegatedTaskTitle(event.agent);
         tasks.set(id, { title, status });
-        await append({ type: "task_update", id, title, status });
+        await append({
+          type: "task_update",
+          id,
+          title,
+          status,
+          ...(event.status === "start"
+            ? {
+                details: `I’m contacting ${shortTaskTitle(event.agent)} for an answer.`,
+              }
+            : {}),
+        });
       } else if (event.type === "agent_call_progress") {
         // A2A calls can stay healthy for minutes. Keep the same native Slack
         // task card alive with each real downstream poll rather than creating
@@ -1550,10 +1600,13 @@ function createSlackRunProgress(
         const id =
           agentTaskIds.get(event.agent) ?? taskId("agent", event.agent);
         agentTaskIds.set(event.agent, id);
-        const title = `Ask ${shortTaskTitle(event.agent)}`;
-        const details = event.detail
-          ? shortTaskTitle(event.detail)
-          : `Still ${event.state} after ${event.elapsedSeconds}s`;
+        const title = delegatedTaskTitle(event.agent);
+        const details = delegatedProgressDetails(
+          event.agent,
+          event.state,
+          event.elapsedSeconds,
+          event.detail,
+        );
         tasks.set(id, { title, status: "in_progress" });
         await append({
           type: "task_update",
@@ -1566,9 +1619,9 @@ function createSlackRunProgress(
         await append({
           type: "task_update",
           id: "agent-native:context",
-          title: "Understand the request",
+          title: "Review the request",
           status: "in_progress",
-          details: shortTaskTitle(event.label),
+          details: `Working · ${shortTaskTitle(event.label)}`,
         });
       }
     },

package/corpus/core/src/integrations/catalog.ts

@@ -137,10 +137,10 @@ const BUILT_IN_CHANNEL_CATALOG = [
     credentialRequirements: [
       {
         key: "SLACK_BOT_TOKEN",
-        label: "Slack Bot Token",
+        label: "Slack Bot Token (legacy)",
         required: false,
         helpText:
-          "OAuth & Permissions → Bot User OAuth Token (starts with `xoxb-`).",
+          "Legacy single-workspace fallback only. For new setups, install Slack from Settings → Messaging; managed OAuth stores each workspace token automatically.",
       },
       {
         key: "SLACK_CLIENT_ID",

package/corpus/core/src/integrations/webhook-handler.ts

@@ -15,6 +15,7 @@ import {
   normalizeModelForEngine,
   resolveEngine,
 } from "../agent/engine/index.js";
+import { resolveMainChatMaxOutputTokens } from "../agent/engine/output-tokens.js";
 import { PROVIDER_TO_ENV } from "../agent/engine/provider-env-vars.js";
 import type { AgentEngine, EngineMessage } from "../agent/engine/types.js";
 import {
@@ -45,6 +46,7 @@ import {
   readDeployCredentialEnv,
 } from "../server/credential-provider.js";
 import { runWithRequestContext } from "../server/request-context.js";
+import { normalizeReasoningEffortForRequest } from "../shared/reasoning-effort.js";
 import { A2A_CONTINUATION_QUEUED_MARKER } from "./a2a-continuation-marker.js";
 import {
   clearIntegrationAwaitingInput,
@@ -866,6 +868,18 @@ async function processIncomingMessage(
               signal,
               threadId,
               approvedToolCalls: incoming.approvedToolCalls,
+              // Messaging integrations are interactive chat surfaces. They
+              // need the same initial completion headroom as web chat so
+              // reasoning cannot consume the small per-engine default and
+              // leave a user-facing Slack reply empty.
+              maxOutputTokens: resolveMainChatMaxOutputTokens(resolvedModel),
+              // Explicitly resolve the normal chat default so an empty-final
+              // retry can step its reasoning effort down rather than
+              // repeatedly letting the engine choose Medium.
+              reasoningEffort: normalizeReasoningEffortForRequest(
+                resolvedModel,
+                undefined,
+              ),
             });
             return usage;
           },