@sentry/junior 0.33.0 → 0.35.0

package/dist/app.js

@@ -3,7 +3,7 @@ import {
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-EHXMTKBA.js";
+} from "./chunk-LAD5O3RX.js";
 import {
   GEN_AI_PROVIDER_NAME,
   MISSING_GATEWAY_CREDENTIALS_ERROR,
@@ -30,13 +30,14 @@ import {
   runNonInteractiveCommand,
   sandboxSkillDir,
   sandboxSkillFile
-} from "./chunk-3M7ZD6FF.js";
+} from "./chunk-ERH4OYNB.js";
 import {
   CredentialUnavailableError,
   buildOAuthTokenRequest,
   createChatSdkLogger,
   createPluginBroker,
   createRequestContext,
+  extractGenAiUsageAttributes,
   extractGenAiUsageSummary,
   getActiveTraceId,
   getPluginCapabilityProviders,
@@ -53,6 +54,7 @@ import {
   logException,
   logInfo,
   logWarn,
+  mergeHeaderTransforms,
   parseOAuthTokenResponse,
   resolveAuthTokenPlaceholder,
   resolveErrorReference,
@@ -64,7 +66,7 @@ import {
   toOptionalString,
   withContext,
   withSpan
-} from "./chunk-XARRBRQV.js";
+} from "./chunk-QZRPUFO6.js";
 import "./chunk-Z3YD6NHK.js";
 import {
   discoverInstalledPluginPackageContent,
@@ -400,6 +402,7 @@ function defaultConversationState() {
   return {
     schemaVersion: 1,
     messages: [],
+    piMessages: [],
     compactions: [],
     backfill: {},
     processing: {},
@@ -511,6 +514,7 @@ function coerceThreadConversationState(value) {
   return {
     schemaVersion: 1,
     messages,
+    piMessages: Array.isArray(rawConversation.piMessages) ? rawConversation.piMessages : [],
     compactions,
     backfill,
     processing,
@@ -2029,20 +2033,6 @@ function getChannelConfigurationServiceById(channelId) {
   });
 }
 
-// src/chat/runtime/thread-participants.ts
-function buildThreadParticipants(messages) {
-  const seen = /* @__PURE__ */ new Set();
-  const participants = [];
-  for (const message of messages) {
-    const { userId, userName, fullName } = message.author ?? {};
-    if (!userId || message.author?.isBot) continue;
-    if (seen.has(userId)) continue;
-    seen.add(userId);
-    participants.push({ userId, userName, fullName });
-  }
-  return participants;
-}
-
 // src/chat/state/turn-id.ts
 function buildDeterministicTurnId(messageId) {
   const sanitized = messageId.replace(/[^a-zA-Z0-9_-]/g, "_");
@@ -2511,7 +2501,7 @@ function getConversationMessageSlackTs(message) {
 }
 
 // src/chat/respond.ts
-import { Agent } from "@mariozechner/pi-agent-core";
+import { Agent as Agent2 } from "@mariozechner/pi-agent-core";
 
 // src/chat/prompt.ts
 import fs from "fs";
@@ -2901,12 +2891,12 @@ function formatConfigurationValue(value) {
     return escapeXml(String(value));
   }
 }
-function renderIdentityBlock(tag, fields) {
+function renderRequesterBlock(fields) {
   const lines = Object.entries(fields).filter(([, value]) => Boolean(value)).map(([key, value]) => `- ${key}: ${escapeXml(value)}`);
   if (lines.length === 0) {
-    return [`<${tag}>`, "none", `</${tag}>`];
+    return null;
   }
-  return [`<${tag}>`, ...lines, `</${tag}>`];
+  return ["<requester>", ...lines, "</requester>"];
 }
 function renderTag(tag, lines) {
   return [`<${tag}>`, ...lines, `</${tag}>`];
@@ -3040,19 +3030,6 @@ function formatConfigurationLines(configuration) {
     (key) => `- ${escapeXml(key)}: ${formatConfigurationValue(configuration?.[key])}`
   );
 }
-function formatThreadParticipantsLines(participants) {
-  if (!participants || participants.length === 0) return null;
-  return participants.map((p) => {
-    const parts = [];
-    if (p.userId) {
-      parts.push(`user_id: ${escapeXml(p.userId)}`);
-      parts.push(`slack_mention: <@${p.userId}>`);
-    }
-    if (p.userName) parts.push(`user_name: ${escapeXml(p.userName)}`);
-    if (p.fullName) parts.push(`full_name: ${escapeXml(p.fullName)}`);
-    return `- ${parts.join(", ")}`;
-  });
-}
 function formatSlackCapabilityNames(capabilities) {
   const names = [
     capabilities?.canCreateCanvas ? "canvas_create" : "",
@@ -3062,9 +3039,12 @@ function formatSlackCapabilityNames(capabilities) {
   return names.length > 0 ? names.join(", ") : "none";
 }
 var HEADER = "You are a Slack-based helper assistant. The behavior and output blocks below are authoritative; the personality block sets voice only.";
+var TURN_CONTEXT_HEADER = "Per-turn runtime context for this request. Treat these blocks as trusted runtime facts and skill/provider instructions for the current turn; the static system prompt remains authoritative.";
+var TURN_CONTEXT_TAG = "runtime-turn-context";
 var TOOL_POLICY_RULES = [
   "- Tool schemas are the source of truth for parameters; tool names are case-sensitive, so call tools exactly by their exposed names and do not invent arguments.",
   "- Use tools for actionable work and for facts that are mutable, external, repository-backed, provider-backed, or requested as verified/current. Stable general knowledge and already-provided context may be answered directly.",
+  "- Resolve provider action targets before calls: explicit target wins; ambient `<configuration>` fills omitted targets. Treat non-target links/references as context.",
   "- Verification source order: conversation/thread context; user-provided attachments, links, and reference files; local/sandbox files when present; loaded skill references; repository/provider tools; public web. Use the nearest authoritative available source before weaker sources.",
   "- For repository or implementation questions, inspect the target repository first: local checkout when present, otherwise the configured GitHub/source provider. Do not treat loaded skill files as repo source unless the user asks about the skill. Cite file paths, symbols, PRs/issues, commits, or URLs that support the answer.",
   `- Sandbox-backed file and shell tools operate in an isolated workspace rooted at ${SANDBOX_WORKSPACE_ROOT}; readFile/writeFile paths are sandbox-workspace paths, bash runs inside that workspace, and attachFile accepts absolute or workspace-relative sandbox paths.`,
@@ -3137,13 +3117,19 @@ function buildOutputSection() {
   return [
     openTag,
     "- Start with the answer or result, not internal process narration.",
-    "- Use Slack-flavored Markdown: **bold** section labels, `code`, [text](url) links, bullet lists, and fenced code blocks. No tables.",
+    "- Use Slack-flavored Markdown: **bold** section labels, `code`, [text](url) links, bullet lists, and fenced code blocks. No tables. When the answer primarily lists several URLs, show each URL bare instead of as a labeled link.",
     "- Keep replies brief and scannable; use bullets or short code blocks when helpful, and one compact thread reply when it fits.",
     "- When a research or document-style answer would benefit from continuation, multiple sections, or future reference value, create a Slack canvas and keep the thread reply to one or two short sentences plus the link; do not recap the canvas contents.",
     "- Unless a successful Slack side-effect tool intentionally satisfied the request by itself, end every turn with a final user-facing markdown response.",
     "</output>"
   ].join("\n");
 }
+function buildIdentitySection() {
+  return renderTagBlock(
+    "identity",
+    `Your Slack username is \`${escapeXml(botConfig.userName)}\`.`
+  );
+}
 function buildRuntimeSection(params) {
   const lines = [
     `- version: ${escapeXml(getRuntimeMetadata().version ?? "unknown")}`,
@@ -3172,29 +3158,13 @@ function buildContextSection(params) {
       ])
     );
   }
-  blocks.push(
-    renderIdentityBlock("assistant", {
-      user_name: params.assistant?.userName ?? botConfig.userName,
-      user_id: params.assistant?.userId
-    })
-  );
-  blocks.push(
-    renderIdentityBlock("requester", {
-      full_name: params.requester?.fullName,
-      user_name: params.requester?.userName,
-      user_id: params.requester?.userId
-    })
-  );
-  const participantLines = formatThreadParticipantsLines(
-    params.threadParticipants
-  );
-  if (participantLines) {
-    blocks.push(
-      renderTag("thread-participants", [
-        "Known participants. When you mention one of these people, use the provided `<@USERID>` token exactly; do not write a bare `@name`.",
-        ...participantLines
-      ])
-    );
+  const requesterLines = renderRequesterBlock({
+    full_name: params.requester?.fullName,
+    user_name: params.requester?.userName,
+    user_id: params.requester?.userId
+  });
+  if (requesterLines) {
+    blocks.push(requesterLines);
   }
   const artifactLines = formatArtifactsLines(params.artifactState);
   if (artifactLines) {
@@ -3204,7 +3174,7 @@ function buildContextSection(params) {
   if (configLines) {
     blocks.push(
       renderTag("configuration", [
-        "Install and conversation-scoped defaults. Channel overrides take precedence; follow explicit user input when it conflicts.",
+        "Ambient provider defaults; explicit targets win.",
         ...configLines
       ])
     );
@@ -3239,27 +3209,35 @@ function buildCapabilitiesSection(params) {
   }
   return renderTagBlock("capabilities", blocks.join("\n\n"));
 }
-function buildSystemPrompt(params) {
+var STATIC_SYSTEM_PROMPT = [
+  HEADER,
+  buildIdentitySection(),
+  renderTagBlock("personality", JUNIOR_PERSONALITY.trim()),
+  renderTagBlock("behavior", buildBehaviorSection()),
+  buildOutputSection()
+].join("\n\n");
+function buildSystemPrompt() {
+  return STATIC_SYSTEM_PROMPT;
+}
+function buildTurnContextPrompt(params) {
   const sections = [
-    HEADER,
-    renderTagBlock("personality", JUNIOR_PERSONALITY.trim()),
-    renderTagBlock("behavior", buildBehaviorSection()),
-    buildOutputSection(),
+    `<${TURN_CONTEXT_TAG}>`,
+    TURN_CONTEXT_HEADER,
+    params.turnState === "resumed" ? "Continue the pending turn from prior conversation history; this block is not a new user request." : "The current user instruction appears after this block in the same message.",
     buildCapabilitiesSection({
       availableSkills: params.availableSkills,
       activeSkills: params.activeSkills,
       activeMcpCatalogs: params.activeMcpCatalogs ?? []
     }),
     buildContextSection({
-      assistant: params.assistant,
       requester: params.requester,
       artifactState: params.artifactState,
       configuration: params.configuration,
-      threadParticipants: params.threadParticipants,
       invocation: params.invocation,
       turnState: params.turnState
     }),
-    buildRuntimeSection(params.runtime ?? {})
+    buildRuntimeSection(params.runtime ?? {}),
+    `</${TURN_CONTEXT_TAG}>`
   ];
   return sections.join("\n\n");
 }
@@ -3366,7 +3344,7 @@ var SkillCapabilityRuntime = class {
       throw new Error("Credential enablement requires requester context");
     }
     const plugin = getPluginDefinition(provider);
-    if (!plugin?.manifest.credentials) {
+    if (!plugin?.manifest.credentials && !plugin?.manifest.apiHeaders) {
       return void 0;
     }
     const existing = this.enabledByProvider.get(provider);
@@ -3498,19 +3476,22 @@ var TestCredentialBroker = class {
   async issue(input) {
     const token = process.env.EVAL_TEST_CREDENTIAL_TOKEN?.trim() || "eval-test-token";
     const expiresAt = new Date(Date.now() + 5 * 60 * 1e3).toISOString();
+    const env = this.config.envKey && this.config.placeholder ? { [this.config.envKey]: this.config.placeholder } : {};
+    const tokenTransforms = this.config.domains?.map((domain) => ({
+      domain,
+      headers: {
+        ...this.config.apiHeaders ?? {},
+        Authorization: `Bearer ${token}`
+      }
+    })) ?? [];
     return {
       id: randomUUID2(),
       provider: this.config.provider,
-      env: {
-        [this.config.envKey]: this.config.placeholder
-      },
-      headerTransforms: this.config.domains.map((domain) => ({
-        domain,
-        headers: {
-          ...this.config.apiHeaders ?? {},
-          Authorization: `Bearer ${token}`
-        }
-      })),
+      env,
+      headerTransforms: mergeHeaderTransforms([
+        ...this.config.headerTransforms?.() ?? [],
+        ...tokenTransforms
+      ]),
       expiresAt,
       metadata: {
         reason: input.reason
@@ -3520,24 +3501,50 @@ var TestCredentialBroker = class {
 };
 
 // src/chat/capabilities/factory.ts
+var ENV_PLACEHOLDER_RE = /\$\{([A-Z_][A-Z0-9_]*)\}/g;
 function createUserTokenStore() {
   return new StateAdapterTokenStore(getStateAdapter());
 }
+function resolveTestApiHeaderTransforms(manifest) {
+  const { apiDomains, apiHeaders } = manifest;
+  if (!apiDomains || !apiHeaders) {
+    return [];
+  }
+  const headers = Object.fromEntries(
+    Object.entries(apiHeaders).map(([key, value]) => [
+      key,
+      value.replace(ENV_PLACEHOLDER_RE, (_match, name) => {
+        return `eval-test-${String(name).toLowerCase().replaceAll("_", "-")}`;
+      })
+    ])
+  );
+  return apiDomains.map((domain) => ({ domain, headers }));
+}
 function createSkillCapabilityRuntime(options = {}) {
   logCapabilityCatalogLoadedOnce();
   const useTestBroker = process.env.EVAL_ENABLE_TEST_CREDENTIALS === "1";
   const userTokenStore = createUserTokenStore();
   const brokersByProvider = {};
   for (const plugin of getPluginProviders()) {
-    const { credentials, name } = plugin.manifest;
+    const { apiHeaders, credentials, name } = plugin.manifest;
+    if (!credentials && !apiHeaders) {
+      continue;
+    }
     if (!credentials) {
+      brokersByProvider[name] = useTestBroker ? new TestCredentialBroker({
+        provider: name,
+        headerTransforms: () => resolveTestApiHeaderTransforms(plugin.manifest)
+      }) : createPluginBroker(name, { userTokenStore });
       continue;
     }
     const placeholder = resolveAuthTokenPlaceholder(credentials);
     brokersByProvider[name] = useTestBroker ? new TestCredentialBroker({
       provider: name,
       domains: credentials.apiDomains,
-      apiHeaders: credentials.apiHeaders,
+      ...credentials.apiHeaders ? { apiHeaders: credentials.apiHeaders } : {},
+      ...apiHeaders ? {
+        headerTransforms: () => resolveTestApiHeaderTransforms(plugin.manifest)
+      } : {},
       envKey: credentials.authTokenEnv,
       placeholder
     }) : createPluginBroker(name, { userTokenStore });
@@ -4108,7 +4115,6 @@ var PluginMcpClient = class {
         setSpanAttributes({
           "mcp.method.name": MCP_TOOLS_CALL_METHOD,
           "gen_ai.operation.name": "execute_tool",
-          "gen_ai.tool.name": name,
           ...this.transport?.sessionId ? { "mcp.session.id": this.transport.sessionId } : {},
           ...this.transport?.protocolVersion ? { "mcp.protocol.version": this.transport.protocolVersion } : {},
           ...getMcpNetworkAttributes(url)
@@ -4458,7 +4464,6 @@ var McpToolManager = class {
       execute: async (args) => {
         const resolvedArgs = typeof args === "object" && args !== null ? args : {};
         const baseAttributes = {
-          "gen_ai.tool.name": tool2.name,
           "mcp.method.name": "tools/call"
         };
         setSpanAttributes(baseAttributes);
@@ -6386,102 +6391,519 @@ function createSystemTimeTool() {
   });
 }
 
-// src/chat/tools/web/fetch-tool.ts
+// src/chat/tools/advisor/tool.ts
+import {
+  Agent
+} from "@mariozechner/pi-agent-core";
 import { Type as Type15 } from "@sinclair/typebox";
 
-// src/chat/tools/web/constants.ts
-var USER_AGENT = "junior-bot/0.1";
-var FETCH_TIMEOUT_MS = 8e3;
-var MAX_REDIRECTS = 3;
-var DEFAULT_MAX_CHARS = 6e3;
-var MAX_FETCH_CHARS = 12e3;
-var MAX_FETCH_BYTES = 256e3;
-
-// src/chat/tools/web/network.ts
-import dns from "dns/promises";
-import http from "http";
-import https from "https";
-import net from "net";
-function isPrivateIpv4(ip) {
-  const parts = ip.split(".").map((chunk) => Number.parseInt(chunk, 10));
-  if (parts.length !== 4 || parts.some((n) => Number.isNaN(n) || n < 0 || n > 255)) {
-    return true;
+// src/chat/respond-helpers.ts
+var MAX_INLINE_ATTACHMENT_BASE64_CHARS = 12e4;
+function getSessionIdentifiers(context) {
+  return {
+    conversationId: context.correlation?.conversationId ?? context.correlation?.threadId ?? context.correlation?.runId,
+    sessionId: context.correlation?.turnId
+  };
+}
+function isExecutionDeferralResponse(text) {
+  return /\b(want me to proceed|do you want me to proceed|shall i proceed|can i proceed|should i proceed|let me do that now|give me a moment|tag me again|fresh invocation)\b/i.test(
+    text
+  );
+}
+function isToolAccessDisclaimerResponse(text) {
+  return /\b(i (don't|do not) have access to (active )?tool|tool results came back empty|prior results .* empty|cannot access .*tool|need to (run|load) .*tool .* first)\b/i.test(
+    text
+  );
+}
+function isExecutionEscapeResponse(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return false;
+  return isExecutionDeferralResponse(trimmed) || isToolAccessDisclaimerResponse(trimmed);
+}
+function parseJsonCandidate(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return void 0;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    const fenced = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+    if (!fenced) return void 0;
+    try {
+      return JSON.parse(fenced[1]);
+    } catch {
+      return void 0;
+    }
   }
-  if (parts[0] === 10 || parts[0] === 127) return true;
-  if (parts[0] === 169 && parts[1] === 254) return true;
-  if (parts[0] === 172 && parts[1] >= 16 && parts[1] <= 31) return true;
-  if (parts[0] === 192 && parts[1] === 168) return true;
-  if (parts[0] === 0) return true;
+}
+function isToolPayloadShape(payload) {
+  if (!payload || typeof payload !== "object") return false;
+  const record = payload;
+  const type = typeof record.type === "string" ? record.type.toLowerCase() : "";
+  if (type.startsWith("tool-")) return true;
+  if (type === "tool_use" || type === "tool_call" || type === "tool_result" || type === "tool_error")
+    return true;
+  const hasToolName = typeof record.toolName === "string" || typeof record.name === "string";
+  const hasToolInput = Object.prototype.hasOwnProperty.call(record, "input") || Object.prototype.hasOwnProperty.call(record, "args");
+  if (hasToolName && hasToolInput) return true;
   return false;
 }
-function parseMappedIpv4FromIpv6(mapped) {
-  if (net.isIP(mapped) === 4) {
-    return mapped;
+function isRawToolPayloadResponse(text) {
+  const parsed = parseJsonCandidate(text);
+  if (Array.isArray(parsed)) {
+    return parsed.some((entry) => isToolPayloadShape(entry));
   }
-  const hexMatch = mapped.match(/^([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i);
-  if (!hexMatch) {
-    return void 0;
+  if (isToolPayloadShape(parsed)) {
+    return true;
   }
-  const high = Number.parseInt(hexMatch[1], 16);
-  const low = Number.parseInt(hexMatch[2], 16);
-  return `${high >> 8 & 255}.${high & 255}.${low >> 8 & 255}.${low & 255}`;
+  const compact = text.replace(/\s+/g, " ");
+  return /"type"\s*:\s*"tool[-_](use|call|result|error)"/i.test(compact);
 }
-function isPrivateIpv6(ip) {
-  const normalized = ip.toLowerCase();
-  if (normalized === "::1" || normalized.startsWith("fc") || normalized.startsWith("fd")) {
-    return true;
+function toObservablePromptPart(part) {
+  if (part.type === "text") {
+    return {
+      type: "text",
+      text: part.text
+    };
   }
-  if (normalized.startsWith("fe")) {
-    const third = normalized[2];
-    if (third === "8" || third === "9" || third === "a" || third === "b") {
-      return true;
-    }
+  return {
+    type: "image",
+    mimeType: part.mimeType,
+    data: `[omitted:${part.data.length}]`
+  };
+}
+function summarizeMessageText(text) {
+  const normalized = text.trim().replace(/\s+/g, " ");
+  if (!normalized) {
+    return "[empty]";
   }
-  if (normalized.startsWith("::ffff:")) {
-    const mapped = normalized.slice("::ffff:".length);
-    const mappedIpv4 = parseMappedIpv4FromIpv6(mapped);
-    if (mappedIpv4 && isPrivateIpv4(mappedIpv4)) {
-      return true;
-    }
+  return normalized.length > 1200 ? `${normalized.slice(0, 1200)}...` : normalized;
+}
+function buildUserTurnText(userInput, conversationContext, metadata) {
+  const trimmedContext = conversationContext?.trim();
+  const conversationId = metadata?.sessionContext?.conversationId;
+  const traceId = metadata?.turnContext?.traceId;
+  if (!trimmedContext && !conversationId && !traceId) {
+    return userInput;
   }
-  return false;
+  const sections = [];
+  if (trimmedContext) {
+    sections.push(
+      "<thread-background>",
+      trimmedContext,
+      "</thread-background>",
+      ""
+    );
+  }
+  if (conversationId) {
+    sections.push(
+      "<session-context>",
+      `- gen_ai.conversation.id: ${conversationId}`,
+      "</session-context>",
+      ""
+    );
+  }
+  if (traceId) {
+    sections.push(
+      "<turn-context>",
+      `- trace_id: ${traceId}`,
+      "</turn-context>",
+      ""
+    );
+  }
+  sections.push(
+    '<current-instruction priority="highest">',
+    userInput,
+    "</current-instruction>"
+  );
+  return sections.join("\n");
 }
-function normalizeHostname(hostname) {
-  const lowered = hostname.toLowerCase();
-  if (lowered.startsWith("[") && lowered.endsWith("]")) {
-    return lowered.slice(1, -1);
+function encodeNonImageAttachmentForPrompt(attachment) {
+  const base64 = attachment.data.toString("base64");
+  const wasTruncated = base64.length > MAX_INLINE_ATTACHMENT_BASE64_CHARS;
+  const encodedPayload = wasTruncated ? `${base64.slice(0, MAX_INLINE_ATTACHMENT_BASE64_CHARS)}...` : base64;
+  return [
+    "<attachment>",
+    `filename: ${attachment.filename ?? "unnamed"}`,
+    `media_type: ${attachment.mediaType}`,
+    "encoding: base64",
+    `truncated: ${wasTruncated ? "true" : "false"}`,
+    "<data_base64>",
+    encodedPayload,
+    "</data_base64>",
+    "</attachment>"
+  ].join("\n");
+}
+function buildExecutionFailureMessage(toolErrorCount) {
+  if (toolErrorCount > 0) {
+    return "I couldn't complete this because one or more required tools failed in this turn. I've logged the failure details.";
   }
-  return lowered;
+  return "I couldn't complete this request in this turn due to an execution failure. I've logged the details for debugging.";
 }
-async function resolvePublicHostname(hostname) {
-  const records = await dns.lookup(hostname, { all: true, verbatim: true });
-  if (records.length === 0) {
-    throw new Error("Could not resolve hostname");
+function isToolResultMessage(value) {
+  return typeof value === "object" && value !== null && value.role === "toolResult";
+}
+function normalizeToolNameFromResult(result) {
+  if (!result || typeof result !== "object") return void 0;
+  const record = result;
+  if (typeof record.toolName === "string" && record.toolName.length > 0) {
+    return record.toolName;
   }
-  const deduped = /* @__PURE__ */ new Map();
-  for (const record of records) {
-    const family = record.family === 6 ? 6 : 4;
-    if (family === 4 && isPrivateIpv4(record.address)) {
-      throw new Error("Resolved to a private IPv4 address");
-    }
-    if (family === 6 && isPrivateIpv6(record.address)) {
-      throw new Error("Resolved to a private IPv6 address");
-    }
-    deduped.set(`${family}:${record.address}`, {
-      address: record.address,
-      family
-    });
+  if (typeof record.name === "string" && record.name.length > 0) {
+    return record.name;
   }
-  return [...deduped.values()];
+  return void 0;
 }
-async function resolvePinnedAddresses(url) {
-  const hostname = normalizeHostname(url.hostname);
-  if (net.isIP(hostname) !== 0) {
-    return void 0;
-  }
-  return resolvePublicHostname(hostname);
+function isToolResultError(result) {
+  if (!result || typeof result !== "object") return false;
+  return Boolean(result.isError);
 }
-function createPinnedLookup(resolved) {
+function isAssistantMessage(value) {
+  return typeof value === "object" && value !== null && value.role === "assistant";
+}
+function getPiMessageRole(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const role = value.role;
+  return typeof role === "string" ? role : void 0;
+}
+function extractAssistantText(message) {
+  const content = message.content ?? [];
+  return content.filter(
+    (part) => part.type === "text" && typeof part.text === "string"
+  ).map((part) => part.text).join("\n");
+}
+function getTerminalAssistantMessages(messages) {
+  let lastToolResultIndex = -1;
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (isToolResultMessage(messages[index])) {
+      lastToolResultIndex = index;
+      break;
+    }
+  }
+  return messages.slice(lastToolResultIndex + 1).filter(isAssistantMessage);
+}
+function upsertActiveSkill(activeSkills, next) {
+  const existing = activeSkills.find((skill) => skill.name === next.name);
+  if (existing) {
+    existing.body = next.body;
+    existing.description = next.description;
+    existing.skillPath = next.skillPath;
+    existing.allowedTools = next.allowedTools;
+    existing.pluginProvider = next.pluginProvider;
+    return;
+  }
+  activeSkills.push(next);
+}
+function trimTrailingAssistantMessages(messages) {
+  let end = messages.length;
+  while (end > 0 && getPiMessageRole(messages[end - 1]) === "assistant") {
+    end -= 1;
+  }
+  return end === messages.length ? [...messages] : messages.slice(0, end);
+}
+
+// src/chat/tools/advisor/session-store.ts
+import { THREAD_STATE_TTL_MS as THREAD_STATE_TTL_MS2 } from "chat";
+var ADVISOR_SESSION_TTL_MS = THREAD_STATE_TTL_MS2;
+function cloneMessages(messages) {
+  return structuredClone(messages);
+}
+function getAdvisorSessionKey(conversationId) {
+  return `junior:${conversationId}:advisor_session`;
+}
+function createStateAdvisorSessionStore() {
+  return {
+    load: async (conversationId) => {
+      const stateAdapter = getStateAdapter();
+      await stateAdapter.connect();
+      const messages = await stateAdapter.get(
+        getAdvisorSessionKey(conversationId)
+      ) ?? [];
+      return cloneMessages(messages);
+    },
+    save: async (conversationId, messages) => {
+      const stateAdapter = getStateAdapter();
+      await stateAdapter.connect();
+      await stateAdapter.set(
+        getAdvisorSessionKey(conversationId),
+        cloneMessages(messages),
+        ADVISOR_SESSION_TTL_MS
+      );
+    }
+  };
+}
+
+// src/chat/tools/advisor/tool.ts
+var ADVISOR_ALLOWED_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "bash",
+  "readFile",
+  "searchMcpTools",
+  "slackCanvasRead",
+  "slackChannelListMessages",
+  "slackListGetItems",
+  "systemTime",
+  "webFetch",
+  "webSearch"
+]);
+var ADVISOR_TOOL_DESCRIPTION = "Ask a stronger advisor for deep technical guidance. Call this when the task has a hard reasoning core: algorithm design, architecture, concurrency, security-sensitive logic, data modeling, unclear requirements, repeated failures, difficult debugging, broad refactors, or final review of nontrivial work. Pass a focused question plus curated context containing the exact evidence, constraints, current plan, alternatives, command output, code snippets, or diffs the advisor should start from. The advisor does not automatically receive the parent transcript, keeps its own advisor history for this parent conversation, can use inspection tools to verify evidence, can reason deeply, and returns guidance for you to apply and verify. Follow-up calls can build on prior advisor guidance but must include any new evidence or changed constraints. Use it after initial orientation reads when repository context matters, before committing to a non-obvious implementation plan, when changing approach, when stuck, and before declaring complex work complete. Do not use it for greetings, simple deterministic edits, routine formatting, or tasks where the next action is already obvious from fresh tool output.";
+var ADVISOR_SYSTEM_PROMPT = [
+  "You are a senior technical advisor for the executor.",
+  "Analyze the executor-supplied context deeply. Use inspection tools when direct inspection or verification would materially improve the advice.",
+  "Distinguish evidence from inference. Treat the advisor task as the focus for this call and the executor context as the starting evidence packet.",
+  "Do not assume access to parent transcript or tool output that was not included or gathered in this advisor call.",
+  "Do not make user-visible side effects, post Slack messages, or mutate files. If a mutating action is needed, recommend it to the executor instead.",
+  "Identify the hard part, recommend a concrete plan or correction, call out blocking risks, and propose focused verification.",
+  "If the supplied context is insufficient, say exactly what additional evidence the executor needs to gather before acting.",
+  "Do not write user-facing prose.",
+  "Use concise technical memo sections when helpful: Assessment, Recommended Plan, Risks, Verification, Stop Conditions."
+].join("\n");
+function lastAssistantMessage(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (isAssistantMessage(message)) {
+      return message;
+    }
+  }
+  return void 0;
+}
+function failure(errorCode, text = `Advisor guidance is unavailable (${errorCode}). Continue only if the next step is clear from verified evidence.`) {
+  return {
+    content: [{ type: "text", text }],
+    details: {
+      ok: false,
+      error_code: errorCode
+    }
+  };
+}
+function success(memo) {
+  return {
+    content: [{ type: "text", text: memo }],
+    details: {
+      ok: true
+    }
+  };
+}
+function isAdvisorToolAllowed(toolName) {
+  return ADVISOR_ALLOWED_TOOL_NAMES.has(toolName);
+}
+function createAdvisorTool(context) {
+  const store = context.store ?? createStateAdvisorSessionStore();
+  const spanContext = context.logContext ?? {};
+  return tool({
+    description: ADVISOR_TOOL_DESCRIPTION,
+    inputSchema: Type15.Object({
+      question: Type15.String({
+        minLength: 1,
+        description: "Focused advisor question or decision point."
+      }),
+      context: Type15.String({
+        minLength: 1,
+        description: "Curated evidence packet: relevant requirements, constraints, current plan, alternatives, code snippets, diffs, command output, and open questions."
+      })
+    }),
+    execute: async ({ question, context: suppliedContext }) => {
+      if (typeof question !== "string" || !question.trim()) {
+        return failure(
+          "invalid_question",
+          "Advisor guidance is unavailable because the question was empty or invalid. Ask a focused advisor question before retrying."
+        );
+      }
+      const advisorQuestion = question.trim();
+      if (typeof suppliedContext !== "string" || !suppliedContext.trim()) {
+        return failure(
+          "invalid_context",
+          "Advisor guidance is unavailable because the curated context was empty or invalid. Include the relevant evidence and constraints before retrying."
+        );
+      }
+      const advisorContext = suppliedContext.trim();
+      if (!context.conversationId) {
+        return failure(
+          "missing_conversation_id",
+          "Advisor guidance is unavailable because this turn has no parent conversation id. Continue without assuming advisor history."
+        );
+      }
+      const conversationId = context.conversationId;
+      return await withSpan(
+        "ai.invoke_advisor",
+        "gen_ai.invoke_agent",
+        spanContext,
+        async () => {
+          const requestText = [
+            "<advisor-task>",
+            escapeXml(advisorQuestion),
+            "</advisor-task>",
+            "",
+            "<executor-context>",
+            escapeXml(advisorContext),
+            "</executor-context>"
+          ].join("\n");
+          const requestMessage = {
+            role: "user",
+            content: [{ type: "text", text: requestText }],
+            timestamp: Date.now()
+          };
+          let advisorMessages;
+          try {
+            advisorMessages = await store.load(conversationId);
+          } catch {
+            setSpanStatus("error");
+            return failure(
+              "session_unavailable",
+              "Advisor guidance is unavailable because advisor history could not be loaded. Continue without assuming advisor history."
+            );
+          }
+          const advisorAgent = new Agent({
+            getApiKey: () => getPiGatewayApiKeyOverride(),
+            initialState: {
+              systemPrompt: ADVISOR_SYSTEM_PROMPT,
+              model: resolveGatewayModel(context.config.modelId),
+              thinkingLevel: context.config.thinkingLevel,
+              tools: context.getTools()
+            },
+            sessionId: getAdvisorSessionKey(conversationId),
+            streamFn: context.streamFn
+          });
+          advisorAgent.state.messages = advisorMessages;
+          const beforeMessageCount = advisorAgent.state.messages.length;
+          try {
+            await advisorAgent.prompt(requestMessage);
+          } catch {
+            setSpanStatus("error");
+            return failure(
+              "unavailable",
+              "Advisor guidance is unavailable. Continue without advisor guidance if the next step is clear from verified evidence."
+            );
+          }
+          const assistant = lastAssistantMessage(advisorAgent.state.messages);
+          const newAdvisorMessages = advisorAgent.state.messages.slice(beforeMessageCount);
+          setSpanAttributes(extractGenAiUsageAttributes(...newAdvisorMessages));
+          if (!assistant || assistant.stopReason === "error" || assistant.stopReason === "aborted") {
+            setSpanStatus("error");
+            return failure(
+              "unavailable",
+              "Advisor guidance is unavailable. Continue without advisor guidance if the next step is clear from verified evidence."
+            );
+          }
+          const memo = extractAssistantText(assistant);
+          try {
+            await store.save(conversationId, advisorAgent.state.messages);
+          } catch {
+            setSpanStatus("error");
+            return failure(
+              "session_unavailable",
+              "Advisor guidance is unavailable because advisor history could not be saved. Retry the advisor call or continue without assuming advisor history."
+            );
+          }
+          setSpanStatus("ok");
+          return success(memo);
+        },
+        {
+          "gen_ai.provider.name": "vercel-ai-gateway",
+          "gen_ai.operation.name": "invoke_agent",
+          "gen_ai.request.model": context.config.modelId
+        }
+      );
+    }
+  });
+}
+
+// src/chat/tools/web/fetch-tool.ts
+import { Type as Type16 } from "@sinclair/typebox";
+
+// src/chat/tools/web/constants.ts
+var USER_AGENT = "junior-bot/0.1";
+var FETCH_TIMEOUT_MS = 8e3;
+var MAX_REDIRECTS = 3;
+var DEFAULT_MAX_CHARS = 6e3;
+var MAX_FETCH_CHARS = 12e3;
+var MAX_FETCH_BYTES = 256e3;
+
+// src/chat/tools/web/network.ts
+import dns from "dns/promises";
+import http from "http";
+import https from "https";
+import net from "net";
+function isPrivateIpv4(ip) {
+  const parts = ip.split(".").map((chunk) => Number.parseInt(chunk, 10));
+  if (parts.length !== 4 || parts.some((n) => Number.isNaN(n) || n < 0 || n > 255)) {
+    return true;
+  }
+  if (parts[0] === 10 || parts[0] === 127) return true;
+  if (parts[0] === 169 && parts[1] === 254) return true;
+  if (parts[0] === 172 && parts[1] >= 16 && parts[1] <= 31) return true;
+  if (parts[0] === 192 && parts[1] === 168) return true;
+  if (parts[0] === 0) return true;
+  return false;
+}
+function parseMappedIpv4FromIpv6(mapped) {
+  if (net.isIP(mapped) === 4) {
+    return mapped;
+  }
+  const hexMatch = mapped.match(/^([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i);
+  if (!hexMatch) {
+    return void 0;
+  }
+  const high = Number.parseInt(hexMatch[1], 16);
+  const low = Number.parseInt(hexMatch[2], 16);
+  return `${high >> 8 & 255}.${high & 255}.${low >> 8 & 255}.${low & 255}`;
+}
+function isPrivateIpv6(ip) {
+  const normalized = ip.toLowerCase();
+  if (normalized === "::1" || normalized.startsWith("fc") || normalized.startsWith("fd")) {
+    return true;
+  }
+  if (normalized.startsWith("fe")) {
+    const third = normalized[2];
+    if (third === "8" || third === "9" || third === "a" || third === "b") {
+      return true;
+    }
+  }
+  if (normalized.startsWith("::ffff:")) {
+    const mapped = normalized.slice("::ffff:".length);
+    const mappedIpv4 = parseMappedIpv4FromIpv6(mapped);
+    if (mappedIpv4 && isPrivateIpv4(mappedIpv4)) {
+      return true;
+    }
+  }
+  return false;
+}
+function normalizeHostname(hostname) {
+  const lowered = hostname.toLowerCase();
+  if (lowered.startsWith("[") && lowered.endsWith("]")) {
+    return lowered.slice(1, -1);
+  }
+  return lowered;
+}
+async function resolvePublicHostname(hostname) {
+  const records = await dns.lookup(hostname, { all: true, verbatim: true });
+  if (records.length === 0) {
+    throw new Error("Could not resolve hostname");
+  }
+  const deduped = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const family = record.family === 6 ? 6 : 4;
+    if (family === 4 && isPrivateIpv4(record.address)) {
+      throw new Error("Resolved to a private IPv4 address");
+    }
+    if (family === 6 && isPrivateIpv6(record.address)) {
+      throw new Error("Resolved to a private IPv6 address");
+    }
+    deduped.set(`${family}:${record.address}`, {
+      address: record.address,
+      family
+    });
+  }
+  return [...deduped.values()];
+}
+async function resolvePinnedAddresses(url) {
+  const hostname = normalizeHostname(url.hostname);
+  if (net.isIP(hostname) !== 0) {
+    return void 0;
+  }
+  return resolvePublicHostname(hostname);
+}
+function createPinnedLookup(resolved) {
   const fallback = resolved[0];
   return (_hostname, options, callback) => {
     if (options?.all) {
@@ -6732,13 +7154,13 @@ function extractHttpStatusFromMessage(message) {
 function createWebFetchTool(hooks) {
   return tool({
     description: "Fetch and extract readable content from a specific URL. Use when you need details from a known page or document. Do not use for discovery when search is the first step.",
-    inputSchema: Type15.Object({
-      url: Type15.String({
+    inputSchema: Type16.Object({
+      url: Type16.String({
         minLength: 1,
         description: "HTTP(S) URL to fetch."
       }),
-      max_chars: Type15.Optional(
-        Type15.Integer({
+      max_chars: Type16.Optional(
+        Type16.Integer({
           minimum: 500,
           maximum: MAX_FETCH_CHARS,
           description: "Optional maximum number of extracted characters to return."
@@ -6798,7 +7220,7 @@ function createWebFetchTool(hooks) {
 // src/chat/tools/web/search.ts
 import { generateText } from "ai";
 import { createGatewayProvider } from "@ai-sdk/gateway";
-import { Type as Type16 } from "@sinclair/typebox";
+import { Type as Type17 } from "@sinclair/typebox";
 var SEARCH_TIMEOUT_MS = 6e4;
 var MAX_RESULTS2 = 5;
 var DEFAULT_SEARCH_MODEL = "xai/grok-4-fast-reasoning";
@@ -6841,14 +7263,14 @@ function isAuthFailure(message) {
 function createWebSearchTool() {
   return tool({
     description: "Search public web sources and return top snippets/URLs. Use when you need discovery or source candidates. Do not use when the user already provided a specific URL to inspect.",
-    inputSchema: Type16.Object({
-      query: Type16.String({
+    inputSchema: Type17.Object({
+      query: Type17.String({
         minLength: 1,
         maxLength: 500,
         description: "Search query."
       }),
-      max_results: Type16.Optional(
-        Type16.Integer({
+      max_results: Type17.Optional(
+        Type17.Integer({
           minimum: 1,
           maximum: MAX_RESULTS2,
           description: "Max results to return."
@@ -6914,17 +7336,17 @@ function createWebSearchTool() {
 }
 
 // src/chat/tools/sandbox/write-file.ts
-import { Type as Type17 } from "@sinclair/typebox";
+import { Type as Type18 } from "@sinclair/typebox";
 function createWriteFileTool() {
   return tool({
     description: "Write UTF-8 content to a file in the sandbox workspace. Use for intentional file creation or replacement after validation. Do not use for exploratory analysis-only turns.",
-    inputSchema: Type17.Object(
+    inputSchema: Type18.Object(
       {
-        path: Type17.String({
+        path: Type18.String({
           minLength: 1,
           description: "Path to write in the sandbox workspace."
         }),
-        content: Type17.String({
+        content: Type18.String({
           description: "UTF-8 file content to write."
         })
       },
@@ -6998,6 +7420,9 @@ function createTools(availableSkills, hooks = {}, context) {
     slackListGetItems: createSlackListGetItemsTool(state),
     slackListUpdateItem: createSlackListUpdateItemTool(state)
   };
+  if (context.advisor) {
+    tools.advisor = createAdvisorTool(context.advisor);
+  }
   if (context.mcpToolManager && context.getActiveSkills) {
     tools.searchMcpTools = createSearchMcpToolsTool(
       context.mcpToolManager,
@@ -8733,324 +9158,111 @@ function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, trac
         "gen_ai.operation.name": "execute_tool",
         "gen_ai.tool.name": toolName,
         ...toolCallId ? { "gen_ai.tool.call.id": toolCallId } : {},
-        ...getToolErrorAttributes(error)
-      },
-      "Agent tool call failed"
-    );
-  }
-  throw error;
-}
-
-// src/chat/tools/agent-tools.ts
-function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor, capabilityRuntime, pluginAuthOrchestration, onToolCall) {
-  const shouldTrace = shouldEmitDevAgentTrace();
-  return Object.entries(tools).map(([toolName, toolDef]) => ({
-    name: toolName,
-    label: toolName,
-    description: toolDef.description,
-    parameters: toolDef.inputSchema,
-    execute: async (toolCallId, params) => {
-      const normalizedToolCallId = typeof toolCallId === "string" && toolCallId.length > 0 ? toolCallId : void 0;
-      const toolArgumentsAttribute = serializeGenAiAttribute(params);
-      const traceToolContext = {
-        ...spanContext,
-        conversationId: spanContext.conversationId,
-        turnId: spanContext.turnId,
-        agentId: spanContext.agentId
-      };
-      if (toolName === "reportProgress") {
-        const status = buildReportedProgressStatus(params);
-        if (status) {
-          await onStatus?.(status);
-        }
-      }
-      return withSpan(
-        `execute_tool ${toolName}`,
-        "gen_ai.execute_tool",
-        spanContext,
-        async () => {
-          const parsed = params;
-          onToolCall?.(toolName, parsed);
-          try {
-            if (typeof toolDef.execute !== "function") {
-              const resultDetails = { ok: true };
-              const toolResultAttribute2 = serializeGenAiAttribute(resultDetails);
-              if (toolResultAttribute2) {
-                setSpanAttributes({
-                  "gen_ai.tool.call.result": toolResultAttribute2
-                });
-              }
-              return {
-                content: [{ type: "text", text: "ok" }],
-                details: resultDetails
-              };
-            }
-            const bashCommand = toolName === "bash" && typeof parsed.command === "string" ? parsed.command.trim() : "";
-            const injection = resolveCredentialInjection(
-              toolName,
-              bashCommand,
-              capabilityRuntime,
-              sandbox
-            );
-            const sandboxInput = buildSandboxInput(toolName, parsed);
-            const isSandbox = Boolean(sandboxExecutor?.canExecute(toolName));
-            const result = isSandbox ? await sandboxExecutor.execute({
-              toolName,
-              input: toolName === "bash" && (injection.headerTransforms || injection.env) ? {
-                ...sandboxInput,
-                ...injection.headerTransforms ? { headerTransforms: injection.headerTransforms } : {},
-                ...injection.env ? { env: injection.env } : {}
-              } : sandboxInput
-            }) : await toolDef.execute(parsed, {
-              experimental_context: sandbox
-            });
-            const normalized = normalizeToolResult(result, isSandbox);
-            if (bashCommand && pluginAuthOrchestration) {
-              await pluginAuthOrchestration.handleCommandFailure({
-                activeSkill: sandbox.getActiveSkill(),
-                command: bashCommand,
-                details: normalized.details
-              });
-            }
-            const toolResultAttribute = serializeGenAiAttribute(
-              normalized.details
-            );
-            if (toolResultAttribute) {
-              setSpanAttributes({
-                "gen_ai.tool.call.result": toolResultAttribute
-              });
-            }
-            return normalized;
-          } catch (error) {
-            if (error instanceof AuthorizationPauseError) {
-              throw error;
-            }
-            handleToolExecutionError(
-              error,
-              toolName,
-              normalizedToolCallId,
-              shouldTrace,
-              traceToolContext
-            );
-          }
-        },
-        {
-          "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
-          "gen_ai.operation.name": "execute_tool",
-          "gen_ai.tool.name": toolName,
-          "gen_ai.tool.description": toolDef.description,
-          ...normalizedToolCallId ? { "gen_ai.tool.call.id": normalizedToolCallId } : {},
-          ...toolArgumentsAttribute ? { "gen_ai.tool.call.arguments": toolArgumentsAttribute } : {}
-        }
-      );
-    }
-  }));
-}
-
-// src/chat/respond-helpers.ts
-var MAX_INLINE_ATTACHMENT_BASE64_CHARS = 12e4;
-function getSessionIdentifiers(context) {
-  return {
-    conversationId: context.correlation?.conversationId ?? context.correlation?.threadId ?? context.correlation?.runId,
-    sessionId: context.correlation?.turnId
-  };
-}
-function isExecutionDeferralResponse(text) {
-  return /\b(want me to proceed|do you want me to proceed|shall i proceed|can i proceed|should i proceed|let me do that now|give me a moment|tag me again|fresh invocation)\b/i.test(
-    text
-  );
-}
-function isToolAccessDisclaimerResponse(text) {
-  return /\b(i (don't|do not) have access to (active )?tool|tool results came back empty|prior results .* empty|cannot access .*tool|need to (run|load) .*tool .* first)\b/i.test(
-    text
-  );
-}
-function isExecutionEscapeResponse(text) {
-  const trimmed = text.trim();
-  if (!trimmed) return false;
-  return isExecutionDeferralResponse(trimmed) || isToolAccessDisclaimerResponse(trimmed);
-}
-function parseJsonCandidate(text) {
-  const trimmed = text.trim();
-  if (!trimmed) return void 0;
-  try {
-    return JSON.parse(trimmed);
-  } catch {
-    const fenced = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
-    if (!fenced) return void 0;
-    try {
-      return JSON.parse(fenced[1]);
-    } catch {
-      return void 0;
-    }
-  }
-}
-function isToolPayloadShape(payload) {
-  if (!payload || typeof payload !== "object") return false;
-  const record = payload;
-  const type = typeof record.type === "string" ? record.type.toLowerCase() : "";
-  if (type.startsWith("tool-")) return true;
-  if (type === "tool_use" || type === "tool_call" || type === "tool_result" || type === "tool_error")
-    return true;
-  const hasToolName = typeof record.toolName === "string" || typeof record.name === "string";
-  const hasToolInput = Object.prototype.hasOwnProperty.call(record, "input") || Object.prototype.hasOwnProperty.call(record, "args");
-  if (hasToolName && hasToolInput) return true;
-  return false;
-}
-function isRawToolPayloadResponse(text) {
-  const parsed = parseJsonCandidate(text);
-  if (Array.isArray(parsed)) {
-    return parsed.some((entry) => isToolPayloadShape(entry));
-  }
-  if (isToolPayloadShape(parsed)) {
-    return true;
-  }
-  const compact = text.replace(/\s+/g, " ");
-  return /"type"\s*:\s*"tool[-_](use|call|result|error)"/i.test(compact);
-}
-function toObservablePromptPart(part) {
-  if (part.type === "text") {
-    return {
-      type: "text",
-      text: part.text
-    };
-  }
-  return {
-    type: "image",
-    mimeType: part.mimeType,
-    data: `[omitted:${part.data.length}]`
-  };
-}
-function summarizeMessageText(text) {
-  const normalized = text.trim().replace(/\s+/g, " ");
-  if (!normalized) {
-    return "[empty]";
-  }
-  return normalized.length > 1200 ? `${normalized.slice(0, 1200)}...` : normalized;
-}
-function buildUserTurnText(userInput, conversationContext, metadata) {
-  const trimmedContext = conversationContext?.trim();
-  const conversationId = metadata?.sessionContext?.conversationId;
-  const traceId = metadata?.turnContext?.traceId;
-  if (!trimmedContext && !conversationId && !traceId) {
-    return userInput;
-  }
-  const sections = [];
-  if (trimmedContext) {
-    sections.push(
-      "<thread-background>",
-      trimmedContext,
-      "</thread-background>",
-      ""
-    );
-  }
-  if (conversationId) {
-    sections.push(
-      "<session-context>",
-      `- gen_ai.conversation.id: ${conversationId}`,
-      "</session-context>",
-      ""
-    );
-  }
-  if (traceId) {
-    sections.push(
-      "<turn-context>",
-      `- trace_id: ${traceId}`,
-      "</turn-context>",
-      ""
-    );
-  }
-  sections.push(
-    '<current-instruction priority="highest">',
-    userInput,
-    "</current-instruction>"
-  );
-  return sections.join("\n");
-}
-function encodeNonImageAttachmentForPrompt(attachment) {
-  const base64 = attachment.data.toString("base64");
-  const wasTruncated = base64.length > MAX_INLINE_ATTACHMENT_BASE64_CHARS;
-  const encodedPayload = wasTruncated ? `${base64.slice(0, MAX_INLINE_ATTACHMENT_BASE64_CHARS)}...` : base64;
-  return [
-    "<attachment>",
-    `filename: ${attachment.filename ?? "unnamed"}`,
-    `media_type: ${attachment.mediaType}`,
-    "encoding: base64",
-    `truncated: ${wasTruncated ? "true" : "false"}`,
-    "<data_base64>",
-    encodedPayload,
-    "</data_base64>",
-    "</attachment>"
-  ].join("\n");
-}
-function buildExecutionFailureMessage(toolErrorCount) {
-  if (toolErrorCount > 0) {
-    return "I couldn't complete this because one or more required tools failed in this turn. I've logged the failure details.";
-  }
-  return "I couldn't complete this request in this turn due to an execution failure. I've logged the details for debugging.";
-}
-function isToolResultMessage(value) {
-  return typeof value === "object" && value !== null && value.role === "toolResult";
-}
-function normalizeToolNameFromResult(result) {
-  if (!result || typeof result !== "object") return void 0;
-  const record = result;
-  if (typeof record.toolName === "string" && record.toolName.length > 0) {
-    return record.toolName;
-  }
-  if (typeof record.name === "string" && record.name.length > 0) {
-    return record.name;
-  }
-  return void 0;
-}
-function isToolResultError(result) {
-  if (!result || typeof result !== "object") return false;
-  return Boolean(result.isError);
-}
-function isAssistantMessage(value) {
-  return typeof value === "object" && value !== null && value.role === "assistant";
-}
-function getPiMessageRole(value) {
-  if (!value || typeof value !== "object") {
-    return void 0;
-  }
-  const role = value.role;
-  return typeof role === "string" ? role : void 0;
-}
-function extractAssistantText(message) {
-  const content = message.content ?? [];
-  return content.filter(
-    (part) => part.type === "text" && typeof part.text === "string"
-  ).map((part) => part.text).join("\n");
-}
-function getTerminalAssistantMessages(messages) {
-  let lastToolResultIndex = -1;
-  for (let index = messages.length - 1; index >= 0; index -= 1) {
-    if (isToolResultMessage(messages[index])) {
-      lastToolResultIndex = index;
-      break;
-    }
-  }
-  return messages.slice(lastToolResultIndex + 1).filter(isAssistantMessage);
-}
-function upsertActiveSkill(activeSkills, next) {
-  const existing = activeSkills.find((skill) => skill.name === next.name);
-  if (existing) {
-    existing.body = next.body;
-    existing.description = next.description;
-    existing.skillPath = next.skillPath;
-    existing.allowedTools = next.allowedTools;
-    existing.pluginProvider = next.pluginProvider;
-    return;
+        ...getToolErrorAttributes(error)
+      },
+      "Agent tool call failed"
+    );
   }
-  activeSkills.push(next);
+  throw error;
 }
-function trimTrailingAssistantMessages(messages) {
-  let end = messages.length;
-  while (end > 0 && getPiMessageRole(messages[end - 1]) === "assistant") {
-    end -= 1;
-  }
-  return end === messages.length ? [...messages] : messages.slice(0, end);
+
+// src/chat/tools/agent-tools.ts
+function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor, capabilityRuntime, pluginAuthOrchestration, onToolCall) {
+  const shouldTrace = shouldEmitDevAgentTrace();
+  return Object.entries(tools).map(([toolName, toolDef]) => ({
+    name: toolName,
+    label: toolName,
+    description: toolDef.description,
+    parameters: toolDef.inputSchema,
+    execute: async (toolCallId, params) => {
+      const normalizedToolCallId = typeof toolCallId === "string" && toolCallId.length > 0 ? toolCallId : void 0;
+      const toolArgumentsAttribute = serializeGenAiAttribute(params);
+      if (toolName === "reportProgress") {
+        const status = buildReportedProgressStatus(params);
+        if (status) {
+          await onStatus?.(status);
+        }
+      }
+      return withSpan(
+        `execute_tool ${toolName}`,
+        "gen_ai.execute_tool",
+        spanContext,
+        async () => {
+          const parsed = params;
+          onToolCall?.(toolName, parsed);
+          try {
+            if (typeof toolDef.execute !== "function") {
+              const resultDetails = { ok: true };
+              const toolResultAttribute2 = serializeGenAiAttribute(resultDetails);
+              if (toolResultAttribute2) {
+                setSpanAttributes({
+                  "gen_ai.tool.call.result": toolResultAttribute2
+                });
+              }
+              return {
+                content: [{ type: "text", text: "ok" }],
+                details: resultDetails
+              };
+            }
+            const bashCommand = toolName === "bash" && typeof parsed.command === "string" ? parsed.command.trim() : "";
+            const injection = resolveCredentialInjection(
+              toolName,
+              bashCommand,
+              capabilityRuntime,
+              sandbox
+            );
+            const sandboxInput = buildSandboxInput(toolName, parsed);
+            const isSandbox = Boolean(sandboxExecutor?.canExecute(toolName));
+            const result = isSandbox ? await sandboxExecutor.execute({
+              toolName,
+              input: toolName === "bash" && (injection.headerTransforms || injection.env) ? {
+                ...sandboxInput,
+                ...injection.headerTransforms ? { headerTransforms: injection.headerTransforms } : {},
+                ...injection.env ? { env: injection.env } : {}
+              } : sandboxInput
+            }) : await toolDef.execute(parsed, {
+              experimental_context: sandbox
+            });
+            const normalized = normalizeToolResult(result, isSandbox);
+            if (bashCommand && pluginAuthOrchestration) {
+              await pluginAuthOrchestration.handleCommandFailure({
+                activeSkill: sandbox.getActiveSkill(),
+                command: bashCommand,
+                details: normalized.details
+              });
+            }
+            const resultAttributeValue = normalized.details && typeof normalized.details === "object" && "rawResult" in normalized.details && normalized.details.rawResult !== void 0 ? normalized.details.rawResult : normalized.details;
+            const toolResultAttribute = serializeGenAiAttribute(resultAttributeValue);
+            if (toolResultAttribute) {
+              setSpanAttributes({
+                "gen_ai.tool.call.result": toolResultAttribute
+              });
+            }
+            return normalized;
+          } catch (error) {
+            if (error instanceof AuthorizationPauseError) {
+              throw error;
+            }
+            handleToolExecutionError(
+              error,
+              toolName,
+              normalizedToolCallId,
+              shouldTrace,
+              spanContext
+            );
+          }
+        },
+        {
+          "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
+          "gen_ai.operation.name": "execute_tool",
+          "gen_ai.tool.name": toolName,
+          "gen_ai.tool.description": toolDef.description,
+          ...normalizedToolCallId ? { "gen_ai.tool.call.id": normalizedToolCallId } : {},
+          ...toolArgumentsAttribute ? { "gen_ai.tool.call.arguments": toolArgumentsAttribute } : {}
+        }
+      );
+    }
+  }));
 }
 
 // src/chat/services/reply-delivery-plan.ts
@@ -9160,6 +9372,7 @@ function buildBriefPostCanvasReply(artifactStatePatch) {
 function buildTurnResult(input) {
   const {
     newMessages,
+    piMessages,
     userInput,
     replyFiles,
     artifactStatePatch,
@@ -9264,6 +9477,7 @@ function buildTurnResult(input) {
     text: resolvedText,
     files: replyFiles.length > 0 ? replyFiles : void 0,
     artifactStatePatch: Object.keys(artifactStatePatch).length > 0 ? artifactStatePatch : void 0,
+    piMessages,
     deliveryPlan,
     deliveryMode,
     sandboxId,
@@ -9696,13 +9910,6 @@ function canReusePendingAuthLink(args) {
   }
   return pendingAuth.kind === args.kind && pendingAuth.provider === args.provider && pendingAuth.requesterId === args.requesterId && pendingAuth.linkSentAtMs + AUTH_LINK_REUSE_WINDOW_MS > (args.nowMs ?? Date.now());
 }
-function buildAuthPauseReplyText(args) {
-  const providerLabel = args.provider ? formatProviderLabel(args.provider) : "";
-  if (args.disposition === "link_already_sent") {
-    return providerLabel ? `I still need your ${providerLabel} access to continue. I already sent you a private link.` : "I still need additional access to continue. I already sent you a private link.";
-  }
-  return providerLabel ? `I need your ${providerLabel} access to continue. I sent you a private link.` : "I need additional access to continue. I sent you a private link.";
-}
 function getConversationPendingAuth(args) {
   const pendingAuth = args.conversation.processing.pendingAuth;
   if (!pendingAuth) {
@@ -9888,13 +10095,17 @@ function commandTargetsProvider(provider, command, details) {
   }
   const plugin = getPluginDefinition(provider);
   const candidates = /* @__PURE__ */ new Set([provider.toLowerCase()]);
-  const credentials = plugin?.manifest.credentials;
+  const manifest = plugin?.manifest;
+  const credentials = manifest?.credentials;
   if (credentials) {
     candidates.add(credentials.authTokenEnv.toLowerCase());
     for (const domain of credentials.apiDomains) {
       candidates.add(domain.toLowerCase());
     }
   }
+  for (const domain of manifest?.apiDomains ?? []) {
+    candidates.add(domain.toLowerCase());
+  }
   const combinedText = `${normalizedCommand}
 ${details.stdout?.toLowerCase() ?? ""}
 ${details.stderr?.toLowerCase() ?? ""}`;
@@ -10078,6 +10289,69 @@ function buildUserTurnInput(args) {
   }
   return { routerBlocks, userContentParts };
 }
+function refreshCheckpointTurnContext(messages, turnContextPrompt) {
+  const marker = getTurnContextMarker(turnContextPrompt);
+  for (let index = 0; index < messages.length; index += 1) {
+    const content = getUserMessageContent(messages[index]);
+    if (!content) {
+      continue;
+    }
+    const contextIndex = content.findIndex(
+      (part) => isTurnContextPart(part, marker)
+    );
+    if (contextIndex < 0) {
+      continue;
+    }
+    const updatedMessages = [...messages];
+    const updatedContent = [...content];
+    updatedContent[contextIndex] = {
+      ...updatedContent[contextIndex],
+      text: turnContextPrompt
+    };
+    updatedMessages[index] = {
+      ...messages[index],
+      content: updatedContent
+    };
+    return updatedMessages;
+  }
+  return [
+    ...messages,
+    {
+      role: "user",
+      content: [{ type: "text", text: turnContextPrompt }],
+      timestamp: Date.now()
+    }
+  ];
+}
+function stripTurnContextFromMessages(messages, turnContextPrompt) {
+  const marker = getTurnContextMarker(turnContextPrompt);
+  return messages.flatMap((message) => {
+    const content = getUserMessageContent(message);
+    if (!content) {
+      return [message];
+    }
+    const strippedContent = content.filter(
+      (part) => !isTurnContextPart(part, marker)
+    );
+    if (strippedContent.length === content.length) {
+      return [message];
+    }
+    if (strippedContent.length === 0) {
+      return [];
+    }
+    return [{ ...message, content: strippedContent }];
+  });
+}
+function getTurnContextMarker(turnContextPrompt) {
+  return turnContextPrompt.split("\n", 1)[0];
+}
+function getUserMessageContent(message) {
+  const record = message;
+  return record.role === "user" && Array.isArray(record.content) ? record.content : void 0;
+}
+function isTurnContextPart(part, marker) {
+  return part !== null && typeof part === "object" && part.type === "text" && typeof part.text === "string" && part.text.startsWith(marker);
+}
 async function generateAssistantReply(messageText, context = {}) {
   const replyStartedAtMs = Date.now();
   let timeoutResumeConversationId;
@@ -10110,7 +10384,7 @@ async function generateAssistantReply(messageText, context = {}) {
       slackUserId: context.correlation?.requesterId,
       slackChannelId: context.correlation?.channelId,
       runId: context.correlation?.runId,
-      assistantUserName: context.assistant?.userName,
+      assistantUserName: botConfig.userName,
       modelId: botConfig.modelId
     };
     const availableSkills = await discoverSkills({
@@ -10264,9 +10538,10 @@ async function generateAssistantReply(messageText, context = {}) {
         upsertActiveSkill(activeSkills, preloaded);
       }
     }
+    const promptConversationContext = context.piMessages && context.piMessages.length > 0 ? void 0 : context.conversationContext;
     const userTurnText = buildUserTurnText(
       userInput,
-      context.conversationContext,
+      promptConversationContext,
       {
         sessionContext: { conversationId: sessionConversationId },
         turnContext: { traceId: getActiveTraceId() }
@@ -10303,6 +10578,7 @@ async function generateAssistantReply(messageText, context = {}) {
     const replyFiles = [];
     const artifactStatePatch = {};
     const toolCalls = [];
+    let advisorTools = [];
     let agent;
     const mcpAuth = createMcpAuthOrchestration(
       {
@@ -10372,7 +10648,7 @@ async function generateAssistantReply(messageText, context = {}) {
       slackUserId: context.correlation?.requesterId,
       slackChannelId: context.correlation?.channelId,
       runId: context.correlation?.runId,
-      assistantUserName: context.assistant?.userName,
+      assistantUserName: botConfig.userName,
       modelId: botConfig.modelId
     });
     const toolChannelId = context.toolChannelId ?? context.correlation?.channelId;
@@ -10439,7 +10715,13 @@ async function generateAssistantReply(messageText, context = {}) {
         configuration: configurationValues,
         getActiveSkills: () => activeSkills,
         mcpToolManager: turnMcpToolManager,
-        sandbox
+        sandbox,
+        advisor: {
+          config: botConfig.advisor,
+          conversationId: sessionConversationId,
+          logContext: spanContext,
+          getTools: () => advisorTools
+        }
       }
     );
     syncResumeState();
@@ -10456,7 +10738,8 @@ async function generateAssistantReply(messageText, context = {}) {
     const activeMcpCatalogs = toActiveMcpCatalogSummaries(
       turnMcpToolManager.getActiveToolCatalog(activeSkills)
     );
-    baseInstructions = buildSystemPrompt({
+    baseInstructions = buildSystemPrompt();
+    const turnContextPrompt = buildTurnContextPrompt({
       availableSkills,
       activeSkills,
       activeMcpCatalogs,
@@ -10468,13 +10751,15 @@ async function generateAssistantReply(messageText, context = {}) {
         thinkingLevel: thinkingSelection.thinkingLevel
       },
       invocation: skillInvocation,
-      assistant: context.assistant,
       requester: context.requester,
       artifactState: context.artifactState,
       configuration: configurationValues,
-      threadParticipants: context.threadParticipants,
       turnState: resumedFromCheckpoint ? "resumed" : "fresh"
     });
+    const promptContentParts = [
+      { type: "text", text: turnContextPrompt },
+      ...userContentParts
+    ];
     const inputMessagesAttribute = serializeGenAiAttribute([
       {
         role: "system",
@@ -10482,7 +10767,7 @@ async function generateAssistantReply(messageText, context = {}) {
       },
       {
         role: "user",
-        content: userContentParts.map((part) => toObservablePromptPart(part))
+        content: promptContentParts.map((part) => toObservablePromptPart(part))
       }
     ]);
     const onToolCall = (toolName, params) => {
@@ -10511,7 +10796,8 @@ async function generateAssistantReply(messageText, context = {}) {
       pluginAuth,
       onToolCall
     );
-    agent = new Agent({
+    advisorTools = agentTools.filter((tool2) => isAdvisorToolAllowed(tool2.name));
+    agent = new Agent2({
       getApiKey: () => getPiGatewayApiKeyOverride(),
       initialState: {
         systemPrompt: baseInstructions,
@@ -10561,7 +10847,12 @@ async function generateAssistantReply(messageText, context = {}) {
     beforeMessageCount = agent.state.messages.length;
     try {
       if (resumedFromCheckpoint) {
-        agent.state.messages = existingCheckpoint.piMessages;
+        agent.state.messages = refreshCheckpointTurnContext(
+          existingCheckpoint.piMessages,
+          turnContextPrompt
+        );
+      } else if (context.piMessages && context.piMessages.length > 0) {
+        agent.state.messages = [...context.piMessages];
       }
       beforeMessageCount = agent.state.messages.length;
       await withSpan(
@@ -10570,14 +10861,9 @@ async function generateAssistantReply(messageText, context = {}) {
         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({
+          const promptPromise = resumedFromCheckpoint ? agent.continue() : agent.prompt({
             role: "user",
-            content: userContentParts,
+            content: promptContentParts,
             timestamp: Date.now()
           });
           let timeoutId;
@@ -10667,6 +10953,10 @@ async function generateAssistantReply(messageText, context = {}) {
     }
     return buildTurnResult({
       newMessages,
+      piMessages: stripTurnContextFromMessages(
+        agent.state.messages,
+        turnContextPrompt
+      ),
       userInput,
       replyFiles,
       artifactStatePatch,
@@ -10680,7 +10970,7 @@ async function generateAssistantReply(messageText, context = {}) {
       usage: turnUsage,
       thinkingSelection,
       correlation: context.correlation,
-      assistantUserName: context.assistant?.userName
+      assistantUserName: botConfig.userName
     });
   } catch (error) {
     if (timedOut && timeoutResumeConversationId && timeoutResumeSessionId) {
@@ -10696,7 +10986,7 @@ async function generateAssistantReply(messageText, context = {}) {
           requesterId: context.correlation?.requesterId,
           channelId: context.correlation?.channelId,
           runId: context.correlation?.runId,
-          assistantUserName: context.assistant?.userName,
+          assistantUserName: botConfig.userName,
           modelId: botConfig.modelId
         }
       });
@@ -10734,7 +11024,7 @@ async function generateAssistantReply(messageText, context = {}) {
           requesterId: context.correlation?.requesterId,
           channelId: context.correlation?.channelId,
           runId: context.correlation?.runId,
-          assistantUserName: context.assistant?.userName,
+          assistantUserName: botConfig.userName,
           modelId: botConfig.modelId
         }
       });
@@ -10765,7 +11055,7 @@ async function generateAssistantReply(messageText, context = {}) {
         slackUserId: context.correlation?.requesterId,
         slackChannelId: context.correlation?.channelId,
         runId: context.correlation?.runId,
-        assistantUserName: context.assistant?.userName,
+        assistantUserName: botConfig.userName,
         modelId: botConfig.modelId
       },
       {},
@@ -11466,10 +11756,6 @@ function createResumeReplyContext(args, statusSession) {
   const persistedChannelConfiguration = replyContext.channelConfiguration ?? (replyContext.configuration ? createReadOnlyConfigService(replyContext.configuration) : void 0);
   return {
     ...replyContext,
-    assistant: {
-      userName: botConfig.userName,
-      ...replyContext.assistant
-    },
     correlation: {
       ...replyContext.correlation,
       threadId: replyContext.correlation?.threadId ?? threadId,
@@ -11622,17 +11908,7 @@ async function resumeAuthorizedRequest(args) {
   });
 }
 
-// src/chat/runtime/auth-pause-reply.ts
-function buildAuthPauseSlackMessage(args) {
-  const footer = buildSlackReplyFooter({
-    conversationId: args.conversationId,
-    durationMs: args.durationMs,
-    thinkingLevel: args.thinkingLevel,
-    usage: args.usage
-  });
-  const blocks = buildSlackReplyBlocks(args.text, footer);
-  return blocks ? { text: args.text, blocks } : { text: args.text };
-}
+// src/chat/runtime/auth-pause-state.ts
 function completeAuthPauseTurn(args) {
   markConversationMessage(
     args.conversation,
@@ -11642,19 +11918,6 @@ function completeAuthPauseTurn(args) {
       skippedReason: void 0
     }
   );
-  upsertConversationMessage(args.conversation, {
-    id: generateConversationId("assistant"),
-    role: "assistant",
-    text: normalizeConversationText(args.text) || "[empty response]",
-    createdAtMs: Date.now(),
-    author: {
-      userName: botConfig.userName,
-      isBot: true
-    },
-    meta: {
-      replied: true
-    }
-  });
   markTurnCompleted({
     conversation: args.conversation,
     nowMs: Date.now(),
@@ -11662,41 +11925,15 @@ function completeAuthPauseTurn(args) {
     updateConversationStats
   });
 }
-async function persistAuthPauseReplyState(args) {
+async function persistAuthPauseTurnState(args) {
   const currentState = await getPersistedThreadState(args.threadStateId);
   const conversation = coerceThreadConversationState(currentState);
   completeAuthPauseTurn({
     conversation,
-    sessionId: args.sessionId,
-    text: args.text
+    sessionId: args.sessionId
   });
   await persistThreadStateById(args.threadStateId, { conversation });
 }
-async function deliverAuthPauseReply(args) {
-  const retryable = isRetryableTurnError(args.error) ? args.error : void 0;
-  const text = retryable ? buildAuthPauseReplyText({
-    disposition: retryable.metadata?.authDisposition,
-    provider: retryable.metadata?.authProvider
-  }) : buildAuthPauseReplyText({ provider: args.fallbackProvider });
-  const message = buildAuthPauseSlackMessage({
-    conversationId: args.conversationId,
-    durationMs: retryable?.metadata?.authDurationMs,
-    text,
-    thinkingLevel: retryable?.metadata?.authThinkingLevel,
-    usage: retryable?.metadata?.authUsage
-  });
-  await postSlackMessage({
-    channelId: args.channelId,
-    threadTs: args.threadTs,
-    text: message.text,
-    ...message.blocks ? { blocks: message.blocks } : {}
-  });
-  await persistAuthPauseReplyState({
-    sessionId: args.sessionId,
-    text,
-    threadStateId: args.threadStateId
-  });
-}
 
 // src/chat/services/timeout-resume.ts
 import { createHmac, timingSafeEqual } from "crypto";
@@ -11888,6 +12125,9 @@ async function persistCompletedReplyState(channelId, threadTs, sessionId, reply)
       replied: true
     }
   });
+  if (reply.piMessages) {
+    conversation.piMessages = reply.piMessages;
+  }
   markTurnCompleted({
     conversation,
     nowMs: Date.now(),
@@ -11968,7 +12208,6 @@ async function resumeAuthorizedMcpTurn(args) {
     connectedText: "",
     failureText: "MCP authorization completed, but resuming the request failed. Please retry the original command.",
     replyContext: {
-      assistant: { userName: botConfig.userName },
       requester: {
         userId: authSession.userId,
         userName: userMessage?.author?.userName,
@@ -11984,11 +12223,11 @@ async function resumeAuthorizedMcpTurn(args) {
       toolChannelId: authSession.toolChannelId ?? artifacts.assistantContextChannelId ?? authSession.channelId,
       conversationContext,
       artifactState: artifacts,
+      piMessages: conversation.piMessages,
       configuration: authSession.configuration,
       pendingAuth,
       channelConfiguration,
       sandbox: getPersistedSandboxState(currentState),
-      threadParticipants: buildThreadParticipants(conversation.messages),
       onAuthPending: async (nextPendingAuth) => {
         await applyPendingAuthUpdate({
           conversation,
@@ -12042,19 +12281,17 @@ async function resumeAuthorizedMcpTurn(args) {
       }
     },
     onAuthPause: async (error) => {
-      await deliverAuthPauseReply({
-        channelId: authSession.channelId,
-        conversationId: authSession.conversationId,
-        error,
-        fallbackProvider: provider,
+      await persistAuthPauseTurnState({
         sessionId: resolvedSessionId,
-        threadStateId: `slack:${authSession.channelId}:${authSession.threadTs}`,
-        threadTs: authSession.threadTs
+        threadStateId: `slack:${authSession.channelId}:${authSession.threadTs}`
       });
       logWarn(
         "mcp_oauth_callback_resume_reparked_for_auth",
         {},
-        { "app.credential.provider": provider },
+        {
+          "app.credential.provider": provider,
+          ...isRetryableTurnError(error) ? { "app.turn.retryable_reason": error.reason } : {}
+        },
         "Resumed MCP turn requested another authorization flow"
       );
     },
@@ -12286,15 +12523,6 @@ async function publishAppHomeView(slackClient, userId, userTokenStore) {
 function htmlErrorResponse(title, message, status) {
   return htmlCallbackResponse(escapeXml(title), escapeXml(message), status);
 }
-async function buildResumeConversationContext2(channelId, threadTs) {
-  const conversation = coerceThreadConversationState(
-    await getPersistedThreadState(`slack:${channelId}:${threadTs}`)
-  );
-  const latestUserMessageId = [...conversation.messages].reverse().find((message) => message.role === "user")?.id;
-  return buildConversationContext(conversation, {
-    excludeMessageId: latestUserMessageId
-  });
-}
 async function buildCheckpointConversationContext(conversationId, sessionId) {
   const conversation = coerceThreadConversationState(
     await getPersistedThreadState(conversationId)
@@ -12328,6 +12556,9 @@ async function persistCompletedOAuthReplyState(args) {
       replied: true
     }
   });
+  if (args.reply.piMessages) {
+    conversation.piMessages = args.reply.piMessages;
+  }
   markTurnCompleted({
     conversation,
     nowMs: Date.now(),
@@ -12426,7 +12657,6 @@ async function resumeCheckpointedOAuthTurn(stored) {
     initialText: "",
     failureText: "I connected your account but hit an error processing your request. Please try the command again.",
     replyContext: {
-      assistant: { userName: botConfig.userName },
       requester: {
         userId: userMessage.author.userId,
         userName: userMessage.author.userName,
@@ -12442,8 +12672,8 @@ async function resumeCheckpointedOAuthTurn(stored) {
       pendingAuth,
       conversationContext,
       channelConfiguration,
+      piMessages: conversation.piMessages,
       sandbox: getPersistedSandboxState(currentState),
-      threadParticipants: buildThreadParticipants(conversation.messages),
       onAuthPending: async (nextPendingAuth) => {
         await applyPendingAuthUpdate({
           conversation,
@@ -12486,15 +12716,10 @@ async function resumeCheckpointedOAuthTurn(stored) {
         sessionId: resolvedSessionId
       });
     },
-    onAuthPause: async (error) => {
-      await deliverAuthPauseReply({
-        channelId: stored.channelId,
-        conversationId: stored.resumeConversationId,
-        error,
-        fallbackProvider: stored.provider,
+    onAuthPause: async () => {
+      await persistAuthPauseTurnState({
         sessionId: resolvedSessionId,
-        threadStateId: stored.resumeConversationId,
-        threadTs: stored.threadTs
+        threadStateId: stored.resumeConversationId
       });
     },
     onTimeoutPause: async (error) => {
@@ -12524,10 +12749,14 @@ async function resumeCheckpointedOAuthTurn(stored) {
 }
 async function resumePendingOAuthMessage(stored) {
   if (!stored.pendingMessage || !stored.channelId || !stored.threadTs) return;
-  const conversationContext = await buildResumeConversationContext2(
-    stored.channelId,
-    stored.threadTs
+  const threadId = `slack:${stored.channelId}:${stored.threadTs}`;
+  const conversation = coerceThreadConversationState(
+    await getPersistedThreadState(threadId)
   );
+  const latestUserMessageId = [...conversation.messages].reverse().find((message) => message.role === "user")?.id;
+  const conversationContext = buildConversationContext(conversation, {
+    excludeMessageId: latestUserMessageId
+  });
   await resumeAuthorizedRequest({
     messageText: stored.pendingMessage,
     channelId: stored.channelId,
@@ -12537,6 +12766,7 @@ async function resumePendingOAuthMessage(stored) {
     replyContext: {
       requester: { userId: stored.userId },
       conversationContext,
+      piMessages: conversation.piMessages,
       configuration: stored.configuration
     },
     onSuccess: async (reply) => {
@@ -12815,6 +13045,9 @@ async function persistCompletedReplyState2(args) {
       replied: true
     }
   });
+  if (args.reply.piMessages) {
+    conversation.piMessages = args.reply.piMessages;
+  }
   markTurnCompleted({
     conversation,
     nowMs: Date.now(),
@@ -12884,7 +13117,6 @@ async function resumeTimedOutTurn(payload) {
     lockKey: payload.conversationId,
     failureText: "I hit an error while resuming that request. Please try the command again.",
     replyContext: {
-      assistant: { userName: botConfig.userName },
       requester: {
         userId: userMessage.author.userId,
         userName: userMessage.author.userName,
@@ -12902,8 +13134,8 @@ async function resumeTimedOutTurn(payload) {
       pendingAuth: conversation.processing.pendingAuth,
       conversationContext,
       channelConfiguration,
+      piMessages: conversation.piMessages,
       sandbox,
-      threadParticipants: buildThreadParticipants(conversation.messages),
       onAuthPending: async (nextPendingAuth) => {
         await applyPendingAuthUpdate({
           conversation,
@@ -12939,20 +13171,17 @@ async function resumeTimedOutTurn(payload) {
         {},
         {
           "app.ai.conversation_id": payload.conversationId,
-          "app.ai.session_id": payload.sessionId
+          "app.ai.session_id": payload.sessionId,
+          ...isRetryableTurnError(error) ? { "app.turn.retryable_reason": error.reason } : {}
         },
         "Failed to resume timed-out turn"
       );
       await persistFailedReplyState2(checkpoint);
     },
-    onAuthPause: async (error) => {
-      await deliverAuthPauseReply({
-        channelId: thread.channelId,
-        conversationId: payload.conversationId,
-        error,
+    onAuthPause: async () => {
+      await persistAuthPauseTurnState({
         sessionId: payload.sessionId,
-        threadStateId: payload.conversationId,
-        threadTs: thread.threadTs
+        threadStateId: payload.conversationId
       });
       logWarn(
         "timeout_resume_reparked_for_auth",
@@ -13485,6 +13714,7 @@ function buildFailureMessage(reference) {
 }
 function buildLogContext(deps, args) {
   return {
+    conversationId: args.threadId ?? args.runId,
     slackThreadId: args.threadId,
     slackUserId: args.requesterId,
     slackUserName: args.requesterUserName,
@@ -13609,78 +13839,6 @@ function createSlackTurnRuntime(deps) {
         const threadId = deps.getThreadId(thread, message);
         const channelId = deps.getChannelId(thread, message);
         const runId = deps.getRunId(thread, message);
-        const rawUserText = message.text;
-        const userText = deps.stripLeadingBotMention(rawUserText, {
-          stripLeadingSlackMentionToken: Boolean(message.isMention)
-        });
-        const context = {
-          threadId,
-          requesterId: message.author.userId,
-          channelId,
-          runId
-        };
-        const preflightDecision = getSubscribedReplyPreflightDecision({
-          botUserName: deps.assistantUserName,
-          rawText: rawUserText,
-          text: userText,
-          isExplicitMention: Boolean(message.isMention)
-        });
-        if (preflightDecision && !preflightDecision.shouldReply) {
-          const reason = preflightDecision.reasonDetail ? `${preflightDecision.reason}:${preflightDecision.reasonDetail}` : preflightDecision.reason;
-          await skipSubscribedMessage({
-            thread,
-            message,
-            decision: { shouldReply: false, reason },
-            context,
-            userText
-          });
-          return;
-        }
-        const preparedState = await deps.prepareTurnState({
-          thread,
-          message,
-          userText,
-          explicitMention: Boolean(message.isMention),
-          context
-        });
-        await deps.persistPreparedState({
-          thread,
-          preparedState
-        });
-        const decision = await deps.decideSubscribedReply({
-          rawText: rawUserText,
-          text: userText,
-          conversationContext: deps.getPreparedConversationContext(preparedState),
-          hasAttachments: message.attachments.length > 0,
-          isExplicitMention: Boolean(message.isMention),
-          context
-        });
-        if (await maybeHandleThreadOptOutDecision({
-          thread,
-          decision,
-          beforeFirstResponsePost: hooks?.beforeFirstResponsePost
-        })) {
-          await skipSubscribedMessage({
-            thread,
-            message,
-            decision,
-            context,
-            preparedState,
-            userText
-          });
-          return;
-        }
-        if (!decision.shouldReply) {
-          await skipSubscribedMessage({
-            thread,
-            message,
-            decision,
-            context,
-            preparedState,
-            userText
-          });
-          return;
-        }
         await deps.withSpan(
           "chat.turn",
           "chat.turn",
@@ -13692,6 +13850,78 @@ function createSlackTurnRuntime(deps) {
             runId
           }),
           async () => {
+            const rawUserText = message.text;
+            const userText = deps.stripLeadingBotMention(rawUserText, {
+              stripLeadingSlackMentionToken: Boolean(message.isMention)
+            });
+            const context = {
+              threadId,
+              requesterId: message.author.userId,
+              channelId,
+              runId
+            };
+            const preflightDecision = getSubscribedReplyPreflightDecision({
+              botUserName: deps.assistantUserName,
+              rawText: rawUserText,
+              text: userText,
+              isExplicitMention: Boolean(message.isMention)
+            });
+            if (preflightDecision && !preflightDecision.shouldReply) {
+              const reason = preflightDecision.reasonDetail ? `${preflightDecision.reason}:${preflightDecision.reasonDetail}` : preflightDecision.reason;
+              await skipSubscribedMessage({
+                thread,
+                message,
+                decision: { shouldReply: false, reason },
+                context,
+                userText
+              });
+              return;
+            }
+            const preparedState = await deps.prepareTurnState({
+              thread,
+              message,
+              userText,
+              explicitMention: Boolean(message.isMention),
+              context
+            });
+            await deps.persistPreparedState({
+              thread,
+              preparedState
+            });
+            const decision = await deps.decideSubscribedReply({
+              rawText: rawUserText,
+              text: userText,
+              conversationContext: deps.getPreparedConversationContext(preparedState),
+              hasAttachments: message.attachments.length > 0,
+              isExplicitMention: Boolean(message.isMention),
+              context
+            });
+            if (await maybeHandleThreadOptOutDecision({
+              thread,
+              decision,
+              beforeFirstResponsePost: hooks?.beforeFirstResponsePost
+            })) {
+              await skipSubscribedMessage({
+                thread,
+                message,
+                decision,
+                context,
+                preparedState,
+                userText
+              });
+              return;
+            }
+            if (!decision.shouldReply) {
+              await skipSubscribedMessage({
+                thread,
+                message,
+                decision,
+                context,
+                preparedState,
+                userText
+              });
+              return;
+            }
             await deps.replyToThread(thread, message, {
               explicitMention: Boolean(message.isMention),
               preparedState,
@@ -14678,13 +14908,7 @@ function createReplyToThread(deps) {
         let shouldPersistFailureState = true;
         try {
           const toolChannelId = preparedState.artifacts.assistantContextChannelId ?? channelId;
-          const threadParticipants = buildThreadParticipants(
-            preparedState.conversation.messages
-          );
           const reply = await deps.services.generateAssistantReply(userText, {
-            assistant: {
-              userName: botConfig.userName
-            },
             requester: {
               userId: message.author.userId,
               userName: message.author.userName ?? fallbackIdentity?.userName,
@@ -14692,6 +14916,7 @@ function createReplyToThread(deps) {
             },
             conversationContext: preparedState.routingContext ?? preparedState.conversationContext,
             artifactState: preparedState.artifacts,
+            piMessages: preparedState.conversation.piMessages,
             pendingAuth: preparedState.conversation.processing.pendingAuth,
             configuration: preparedState.configuration,
             channelConfiguration: preparedState.channelConfiguration,
@@ -14732,7 +14957,6 @@ function createReplyToThread(deps) {
                 conversation: preparedState.conversation
               });
             },
-            threadParticipants,
             onStatus: (nextStatus) => status.update(nextStatus)
           });
           const diagnosticsContext = {
@@ -14808,6 +15032,9 @@ function createReplyToThread(deps) {
               replied: true
             }
           });
+          if (reply.piMessages) {
+            preparedState.conversation.piMessages = reply.piMessages;
+          }
           const artifactStatePatch = reply.artifactStatePatch ? { ...reply.artifactStatePatch } : {};
           const reactionPerformed = reply.diagnostics.toolCalls.includes(
             "slackMessageAddReaction"
@@ -14909,35 +15136,9 @@ function createReplyToThread(deps) {
           }
         } catch (error) {
           if (isRetryableTurnError(error, "mcp_auth_resume") || isRetryableTurnError(error, "plugin_auth_resume")) {
-            const authPauseText = buildAuthPauseReplyText({
-              disposition: error.metadata?.authDisposition,
-              provider: error.metadata?.authProvider
-            });
-            const authPauseFooter = buildSlackReplyFooter({
-              conversationId,
-              durationMs: error.metadata?.authDurationMs,
-              thinkingLevel: error.metadata?.authThinkingLevel,
-              usage: error.metadata?.authUsage
-            });
-            const useSlackFooterForAuthPause = Boolean(authPauseFooter) && Boolean(channelId && threadTs) && thread.adapter?.name === "slack";
-            if (useSlackFooterForAuthPause && channelId && threadTs) {
-              await beforeFirstResponsePost();
-              await postSlackApiReplyPosts({
-                channelId,
-                threadTs,
-                footer: authPauseFooter,
-                posts: [{ stage: "thread_reply", text: authPauseText }]
-              });
-            } else {
-              await postThreadReply(
-                buildSlackOutputMessage(authPauseText),
-                "thread_reply"
-              );
-            }
             completeAuthPauseTurn({
               conversation: preparedState.conversation,
-              sessionId: error.metadata?.sessionId ?? turnId,
-              text: authPauseText
+              sessionId: error.metadata?.sessionId ?? turnId
             });
             await persistThreadState(thread, {
               conversation: preparedState.conversation