@sentry/junior 0.57.0 → 0.59.0

package/dist/app.js

@@ -1,38 +1,66 @@
+import {
+  GET,
+  abandonAgentTurnSessionRecord,
+  buildSentryConversationUrl,
+  commitMessages,
+  failAgentTurnSessionRecord,
+  getAgentTurnSessionRecord,
+  loadConnectedMcpProviders,
+  loadProjection,
+  recordAgentTurnSessionSummary,
+  recordAuthorizationCompleted,
+  recordAuthorizationRequested,
+  recordMcpProviderConnected,
+  upsertAgentTurnSessionRecord
+} from "./chunk-I4FDGMFI.js";
 import {
   discoverSkills,
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-D3G3YOU4.js";
+} from "./chunk-ITOW4DED.js";
 import {
-  ACTIVE_LOCK_TTL_MS,
-  GEN_AI_PROVIDER_NAME,
-  MISSING_GATEWAY_CREDENTIALS_ERROR,
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
   SANDBOX_WORKSPACE_ROOT,
-  botConfig,
   buildNonInteractiveShellScript,
+  createSandboxInstance,
+  getRuntimeDependencyProfileHash,
+  getVercelSandboxCredentials,
+  isSnapshotMissingError,
+  resolveRuntimeDependencySnapshot,
+  runNonInteractiveCommand,
+  sandboxSkillDir,
+  sandboxSkillFile
+} from "./chunk-QDGD5WVN.js";
+import {
+  ACTIVE_LOCK_TTL_MS,
+  GEN_AI_PROVIDER_NAME,
+  GEN_AI_SERVER_ADDRESS,
+  GEN_AI_SERVER_PORT,
+  MISSING_GATEWAY_CREDENTIALS_ERROR,
+  botConfig,
   completeObject,
   completeText,
-  createSandboxInstance,
   getGatewayApiKey,
   getPiGatewayApiKeyOverride,
-  getRuntimeDependencyProfileHash,
   getRuntimeMetadata,
   getSlackBotToken,
   getSlackClientId,
   getSlackClientSecret,
   getSlackSigningSecret,
   getStateAdapter,
-  getVercelSandboxCredentials,
-  isSnapshotMissingError,
+  parseSlackThreadId,
+  resolveConversationPrivacy,
   resolveGatewayModel,
-  resolveRuntimeDependencySnapshot,
-  runNonInteractiveCommand,
-  sandboxSkillDir,
-  sandboxSkillFile
-} from "./chunk-AA5TIFN5.js";
+  resolveSlackChannelIdFromMessage,
+  resolveSlackChannelIdFromThreadId,
+  toGenAiMessageMetadata,
+  toGenAiMessagesTraceAttributes,
+  toGenAiPayloadMetadata,
+  toGenAiPayloadTraceAttributes,
+  toGenAiTextMetadata
+} from "./chunk-FKEKRBUB.js";
 import {
   CredentialUnavailableError,
   buildOAuthTokenRequest,
@@ -49,7 +77,6 @@ import {
   getPluginDefinition,
   getPluginMcpProviders,
   getPluginOAuthConfig,
-  getPluginPackageContent,
   getPluginProviders,
   hasRequiredOAuthScope,
   isPluginConfigKey,
@@ -59,6 +86,7 @@ import {
   logException,
   logInfo,
   logWarn,
+  normalizeGenAiFinishReason,
   parseOAuthTokenResponse,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv,
@@ -71,7 +99,7 @@ import {
   toOptionalString,
   withContext,
   withSpan
-} from "./chunk-TTUY467K.js";
+} from "./chunk-H652GMDH.js";
 import {
   sentry_exports
 } from "./chunk-Z3YD6NHK.js";
@@ -468,252 +496,13 @@ function createAgentPluginHookRunner(input = {}) {
   };
 }
 
-// src/handlers/diagnostics.ts
-import { readFileSync } from "fs";
-import path from "path";
-function readDescriptionText() {
-  try {
-    const raw = readFileSync(
-      path.join(homeDir(), "DESCRIPTION.md"),
-      "utf8"
-    ).trim();
-    return raw || void 0;
-  } catch {
-    return void 0;
-  }
-}
-async function GET() {
-  const packagedContent = getPluginPackageContent();
-  const skills = await discoverSkills();
-  return Response.json({
-    cwd: process.cwd(),
-    homeDir: homeDir(),
-    descriptionText: readDescriptionText(),
-    providers: getPluginProviders().map((plugin) => plugin.manifest.name),
-    skills: skills.map((skill) => ({
-      name: skill.name,
-      pluginProvider: skill.pluginProvider
-    })),
-    packagedContent
-  });
-}
-
-// src/chat/xml.ts
-function escapeXml(value) {
-  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
-}
-
-// src/handlers/health.ts
-function GET2() {
-  return Response.json({
-    status: "ok",
-    service: "junior",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  });
-}
-
-// src/handlers/diagnostics-dashboard.ts
-async function GET3() {
-  let health;
-  let discovery;
-  try {
-    const res = await GET2();
-    health = {
-      ok: res.ok,
-      data: await res.json()
-    };
-  } catch (e) {
-    health = { ok: false, error: String(e) };
-  }
-  try {
-    const res = await GET();
-    if (res.ok) {
-      discovery = {
-        ok: true,
-        data: await res.json()
-      };
-    } else {
-      discovery = { ok: false, error: `${res.status} ${res.statusText}` };
-    }
-  } catch (e) {
-    discovery = { ok: false, error: String(e) };
-  }
-  const d = discovery.ok ? discovery.data : null;
-  let html = `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="utf-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <title>Junior</title>
-  <style>
-    *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
-    body {
-      font-family: "SF Mono", "Cascadia Code", "Fira Code", Menlo, monospace;
-      background: #0d1117; color: #c9d1d9; padding: 2rem;
-      font-size: 14px; line-height: 1.6;
-    }
-    h1 { color: #58a6ff; font-size: 1.1rem; margin-bottom: 0.25rem; }
-    .subtitle { color: #8b949e; font-size: 0.85rem; margin-bottom: 1.5rem; }
-    .section { max-width: 720px; margin-bottom: 1.25rem; }
-    .section-title {
-      color: #8b949e; font-size: 0.75rem; text-transform: uppercase;
-      letter-spacing: 0.08em; margin-bottom: 0.5rem; padding-bottom: 0.25rem;
-      border-bottom: 1px solid #21262d;
-    }
-    .status-row { display: flex; align-items: center; gap: 0.5rem; margin-bottom: 0.35rem; }
-    .dot { width: 8px; height: 8px; border-radius: 50%; flex-shrink: 0; }
-    .dot-ok { background: #2dd4bf; }
-    .dot-err { background: #f87171; }
-    .label { color: #8b949e; }
-    .value { color: #e6edf3; }
-    .detail-row { display: flex; gap: 0.5rem; margin-bottom: 0.25rem; font-size: 0.85rem; }
-    .detail-key { color: #8b949e; min-width: 7rem; }
-    .detail-val { color: #c9d1d9; }
-    .skill-grid { display: flex; flex-wrap: wrap; gap: 0.4rem; }
-    .skill-tag {
-      background: #161b22; border: 1px solid #30363d; border-radius: 4px;
-      padding: 0.2rem 0.5rem; font-size: 0.8rem; color: #c9d1d9;
-    }
-    .skill-provider { color: #8b949e; font-size: 0.7rem; margin-left: 0.15rem; }
-    .provider-list, .package-list { display: flex; flex-wrap: wrap; gap: 0.4rem; }
-    .provider-tag {
-      background: #1b2332; border: 1px solid #1f3a5f; border-radius: 4px;
-      padding: 0.2rem 0.5rem; font-size: 0.8rem; color: #58a6ff;
-    }
-    .package-tag {
-      background: #1a1e2a; border: 1px solid #2d3548; border-radius: 4px;
-      padding: 0.2rem 0.5rem; font-size: 0.78rem; color: #a5b4cf;
-    }
-    .endpoint-list { list-style: none; }
-    .endpoint-list li { margin-bottom: 0.2rem; font-size: 0.85rem; }
-    .method {
-      display: inline-block; font-size: 0.7rem; font-weight: 600;
-      padding: 0.1rem 0.35rem; border-radius: 3px; margin-right: 0.4rem;
-      min-width: 2.5rem; text-align: center;
-    }
-    .method-get { background: #1b3a2d; color: #2dd4bf; }
-    .method-post { background: #3b2e1a; color: #f0b952; }
-    .endpoint-link { color: #c9d1d9; text-decoration: none; }
-    .endpoint-link:hover { color: #58a6ff; text-decoration: underline; }
-    .error-msg { color: #f87171; font-size: 0.85rem; }
-  </style>
-</head>
-<body>
-  <h1>&gt; junior</h1>`;
-  if (d?.descriptionText) {
-    html += `
-  <div class="subtitle">${escapeXml(String(d.descriptionText))}</div>`;
-  }
-  html += `
-  <div class="section">
-    <div class="section-title">Status</div>
-    <div class="status-row">
-      <span class="dot ${health.ok ? "dot-ok" : "dot-err"}"></span>
-      <span class="value">${health.ok ? "Healthy" : "Unreachable"}</span>`;
-  if (health.ok && health.data?.timestamp) {
-    html += `
-      <span class="label">&middot; ${escapeXml(new Date(health.data.timestamp).toLocaleTimeString())}</span>`;
-  }
-  html += `
-    </div>`;
-  if (d) {
-    html += `
-    <div class="detail-row"><span class="detail-key">service</span><span class="detail-val">${escapeXml(String(health.data?.service ?? "junior"))}</span></div>`;
-    html += `
-    <div class="detail-row"><span class="detail-key">cwd</span><span class="detail-val">${escapeXml(String(d.cwd))}</span></div>`;
-    html += `
-    <div class="detail-row"><span class="detail-key">home</span><span class="detail-val">${escapeXml(String(d.homeDir))}</span></div>`;
-  }
-  html += `
-  </div>`;
-  const endpoints = [
-    { method: "GET", path: "/health" },
-    { method: "GET", path: "/api/info" },
-    { method: "GET", path: "/api/oauth/callback/mcp/:provider" },
-    { method: "GET", path: "/api/oauth/callback/:provider" },
-    { method: "POST", path: "/api/internal/agent-dispatch" },
-    { method: "GET", path: "/api/internal/heartbeat" },
-    { method: "POST", path: "/api/webhooks/:platform" }
-  ];
-  html += `
-  <div class="section">
-    <div class="section-title">Endpoints</div>
-    <ul class="endpoint-list">`;
-  for (const ep of endpoints) {
-    const cls = ep.method === "GET" ? "method-get" : "method-post";
-    const link = ep.path.includes(":") ? `<span>${escapeXml(ep.path)}</span>` : `<a class="endpoint-link" href="${escapeXml(ep.path)}" target="_blank">${escapeXml(ep.path)}</a>`;
-    html += `
-      <li><span class="method ${cls}">${escapeXml(ep.method)}</span>${link}</li>`;
-  }
-  html += `
-    </ul>
-  </div>`;
-  if (d) {
-    const providers = d.providers;
-    const packagedContent = d.packagedContent;
-    const skills = d.skills;
-    if (providers?.length) {
-      html += `
-  <div class="section">
-    <div class="section-title">Plugins <span class="label">(${providers.length})</span></div>
-    <div class="provider-list">`;
-      for (const p of providers) {
-        html += `
-      <span class="provider-tag">${escapeXml(p)}</span>`;
-      }
-      html += `
-    </div>`;
-      if (packagedContent?.packageNames?.length) {
-        html += `
-    <div style="margin-top:0.5rem"><div class="package-list">`;
-        for (const pkg of packagedContent.packageNames) {
-          html += `
-      <span class="package-tag">${escapeXml(pkg)}</span>`;
-        }
-        html += `
-    </div></div>`;
-      }
-      html += `
-  </div>`;
-    }
-    if (skills?.length) {
-      html += `
-  <div class="section">
-    <div class="section-title">Skills <span class="label">(${skills.length})</span></div>
-    <div class="skill-grid">`;
-      for (const s of skills) {
-        html += `
-      <span class="skill-tag">${escapeXml(s.name)}`;
-        if (s.pluginProvider) {
-          html += ` <span class="skill-provider">${escapeXml(s.pluginProvider)}</span>`;
-        }
-        html += `</span>`;
-      }
-      html += `
-    </div>
-  </div>`;
-    }
-  } else if (!discovery.ok) {
-    html += `
-  <div class="section">
-    <div class="section-title">Discovery</div>
-    <span class="error-msg">unavailable &middot; ${escapeXml(discovery.error ?? "unknown")}</span>
-  </div>`;
-  }
-  html += `
-</body>
-</html>`;
-  return new Response(html, {
-    headers: { "content-type": "text/html; charset=utf-8" }
-  });
-}
-
 // src/chat/respond.ts
 import { Agent as Agent2 } from "@earendil-works/pi-agent-core";
+import { THREAD_STATE_TTL_MS as THREAD_STATE_TTL_MS3 } from "chat";
 
 // src/chat/prompt.ts
 import fs from "fs";
-import path2 from "path";
+import path from "path";
 
 // src/chat/turn-context-tag.ts
 var TURN_CONTEXT_TAG = "runtime-turn-context";
@@ -999,6 +788,11 @@ var slackOutputPolicy = {
   maxInlineLines: MAX_INLINE_LINES
 };
 
+// src/chat/xml.ts
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+
 // src/chat/prompt.ts
 var DEFAULT_SOUL = "You are Junior, a practical and concise assistant.";
 function getLoggedMarkdownFiles() {
@@ -1127,7 +921,7 @@ function formatAvailableSkillsForPrompt(skills, invocation) {
   if (autoSelectable.length > 0) {
     const available = [
       "<available-skills>",
-      "Scan before answering. Load the most specific matching skill; do not answer from memory when a skill fits. If none fits, do not load a skill."
+      "Scan before answering. Load the most specific matching skill; do not answer from memory when a skill fits. A request that names a skill, plugin, provider, or account matching a skill name is a skill match. If none fits, do not load a skill."
     ];
     for (const skill of autoSelectable) {
       available.push(...formatSkillEntry(skill));
@@ -1148,26 +942,6 @@ function formatAvailableSkillsForPrompt(skills, invocation) {
   }
   return sections.length > 0 ? sections.join("\n") : null;
 }
-function formatLoadedSkillsForPrompt(skills) {
-  if (skills.length === 0) {
-    return null;
-  }
-  const lines = ["<loaded-skills>"];
-  for (const skill of skills) {
-    const skillDir = workspaceSkillDir(skill.name);
-    lines.push(
-      `  <skill name="${escapeXml(skill.name)}" location="${escapeXml(`${skillDir}/SKILL.md`)}">`
-    );
-    lines.push(
-      `Skill directory: ${escapeXml(skillDir)}. Resolve relative paths there; for skill-owned bash commands, cd there first or use absolute paths.`
-    );
-    lines.push("");
-    lines.push(skill.body);
-    lines.push("  </skill>");
-  }
-  lines.push("</loaded-skills>");
-  return lines.join("\n");
-}
 function formatActiveMcpCatalogsForPrompt(catalogs) {
   if (catalogs.length === 0) {
     return null;
@@ -1213,7 +987,7 @@ function formatReferenceFilesLines() {
     return null;
   }
   return files.map((filePath) => {
-    const name = path2.basename(filePath);
+    const name = path.basename(filePath);
     return `- ${escapeXml(name)} (${escapeXml(`${SANDBOX_DATA_ROOT}/${name}`)})`;
   });
 }
@@ -1255,7 +1029,7 @@ function formatConfigurationLines(configuration) {
   );
 }
 var HEADER = "You are a Slack-based helper assistant. Follow the personality block for voice and tone in every reply. The behavior and output blocks define platform mechanics and override personality only when those mechanics conflict.";
-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_HEADER = "Runtime context for this request. Treat these blocks as trusted runtime facts; the static system prompt remains authoritative.";
 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.",
@@ -1275,7 +1049,7 @@ var TOOL_CALL_STYLE_RULES = [
 ];
 var SKILL_POLICY_RULES = [
   "- Only load skills listed in `<available-skills>`, `<user-callable-skills>`, or named by `<explicit-skill-trigger>`. Never guess or invent a skill name.",
-  "- Load one skill at a time. After `loadSkill`, follow the instructions in `<loaded-skills>`."
+  "- Load one skill at a time. After `loadSkill`, follow the instructions returned by that tool result."
 ];
 var EXECUTION_CONTRACT_RULES = [
   "- Actionable request: act in this turn.",
@@ -1386,12 +1160,6 @@ function buildContextSection(params) {
       ])
     );
   }
-  if (params.turnState === "resumed") {
-    blocks.push([
-      "<turn-state>resumed</turn-state>",
-      "This turn continues from a prior checkpoint. Prior tool results and assistant messages are already in the conversation history."
-    ]);
-  }
   if (params.invocation) {
     blocks.push(
       renderTag("explicit-skill-trigger", [
@@ -1415,10 +1183,6 @@ function buildCapabilitiesSection(params) {
   if (availableSkills) {
     blocks.push(availableSkills);
   }
-  const loadedSkills = formatLoadedSkillsForPrompt(params.activeSkills);
-  if (loadedSkills) {
-    blocks.push(loadedSkills);
-  }
   const activeCatalogs = formatActiveMcpCatalogsForPrompt(
     params.activeMcpCatalogs
   );
@@ -1445,13 +1209,13 @@ function buildSystemPrompt() {
   return STATIC_SYSTEM_PROMPT;
 }
 function buildTurnContextPrompt(params) {
-  const sections = [
-    `<${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.",
+  const includeSessionContext = params.includeSessionContext ?? true;
+  if (!includeSessionContext) {
+    return null;
+  }
+  const runtimeSections = [
     buildCapabilitiesSection({
       availableSkills: params.availableSkills,
-      activeSkills: params.activeSkills,
       activeMcpCatalogs: params.activeMcpCatalogs ?? [],
       invocation: params.invocation,
       toolGuidance: params.toolGuidance ?? []
@@ -1460,10 +1224,18 @@ function buildTurnContextPrompt(params) {
       requester: params.requester,
       artifactState: params.artifactState,
       configuration: params.configuration,
-      invocation: params.invocation,
-      turnState: params.turnState
+      invocation: params.invocation
     }),
-    buildRuntimeSection(params.runtime ?? {}),
+    buildRuntimeSection(params.runtime ?? {})
+  ].filter((section) => Boolean(section));
+  if (runtimeSections.length === 0) {
+    return null;
+  }
+  const sections = [
+    `<${TURN_CONTEXT_TAG}>`,
+    TURN_CONTEXT_HEADER,
+    "The current user instruction appears after this block in the same message.",
+    ...runtimeSections,
     `</${TURN_CONTEXT_TAG}>`
   ].filter((section) => Boolean(section));
   return sections.join("\n\n");
@@ -1864,12 +1636,12 @@ async function maybeExecuteJrRpcCustomCommand(command, deps) {
 
 // src/chat/sandbox/skill-sandbox.ts
 import fs2 from "fs/promises";
-import path3 from "path";
+import path2 from "path";
 var MAX_SKILL_FILE_BYTES = 256 * 1024;
 var DEFAULT_MAX_SKILL_FILE_CHARS = 2e4;
 var DEFAULT_MAX_SKILL_LIST_ENTRIES = 200;
 function normalizePathForOutput(value) {
-  return value.split(path3.sep).join("/");
+  return value.split(path2.sep).join("/");
 }
 function normalizeSkillName(value) {
   return value.trim().toLowerCase();
@@ -1878,12 +1650,12 @@ function resolvePathWithinRoot(root, relativePath) {
   if (!relativePath.trim()) {
     throw new Error("Path must not be empty.");
   }
-  if (path3.isAbsolute(relativePath)) {
+  if (path2.isAbsolute(relativePath)) {
     throw new Error("Absolute paths are not allowed.");
   }
-  const resolvedRoot = path3.resolve(root);
-  const resolvedPath = path3.resolve(resolvedRoot, relativePath);
-  if (resolvedPath !== resolvedRoot && !resolvedPath.startsWith(`${resolvedRoot}${path3.sep}`)) {
+  const resolvedRoot = path2.resolve(root);
+  const resolvedPath = path2.resolve(resolvedRoot, relativePath);
+  if (resolvedPath !== resolvedRoot && !resolvedPath.startsWith(`${resolvedRoot}${path2.sep}`)) {
     throw new Error("Path escapes the skill directory.");
   }
   return resolvedPath;
@@ -1963,7 +1735,7 @@ var SkillSandbox = class {
       1,
       Math.min(params.maxEntries ?? DEFAULT_MAX_SKILL_LIST_ENTRIES, 1e3)
     );
-    const root = path3.resolve(skill.skillPath);
+    const root = path2.resolve(skill.skillPath);
     const targetDirectory = resolvePathWithinRoot(root, directory);
     const targetStats = await fs2.stat(targetDirectory);
     if (!targetStats.isDirectory()) {
@@ -1979,9 +1751,9 @@ var SkillSandbox = class {
       });
       children.sort((a, b) => a.name.localeCompare(b.name));
       for (const child of children) {
-        const absolutePath = path3.join(currentDirectory, child.name);
+        const absolutePath = path2.join(currentDirectory, child.name);
         const relativePath = normalizePathForOutput(
-          path3.relative(root, absolutePath)
+          path2.relative(root, absolutePath)
         );
         if (!relativePath || relativePath.startsWith("..")) {
           continue;
@@ -2004,7 +1776,7 @@ var SkillSandbox = class {
       }
     }
     const relativeDirectory = normalizePathForOutput(
-      path3.relative(root, targetDirectory) || "."
+      path2.relative(root, targetDirectory) || "."
     );
     return {
       skillName: skill.name,
@@ -2019,7 +1791,7 @@ var SkillSandbox = class {
       1,
       Math.min(params.maxChars ?? DEFAULT_MAX_SKILL_FILE_CHARS, 1e5)
     );
-    const root = path3.resolve(skill.skillPath);
+    const root = path2.resolve(skill.skillPath);
     const targetPath = resolvePathWithinRoot(root, params.filePath);
     const stats = await fs2.stat(targetPath);
     if (!stats.isFile()) {
@@ -2034,7 +1806,7 @@ var SkillSandbox = class {
     const truncated = raw.length > maxChars;
     return {
       skillName: skill.name,
-      path: normalizePathForOutput(path3.relative(root, targetPath)),
+      path: normalizePathForOutput(path2.relative(root, targetPath)),
       content: truncated ? raw.slice(0, maxChars) : raw,
       truncated
     };
@@ -2402,6 +2174,14 @@ var McpToolManager = class {
       (left, right) => left.localeCompare(right)
     );
   }
+  /** List configured MCP providers for discovery without connecting to them. */
+  getAvailableProviderCatalog() {
+    return [...this.pluginsByProvider.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([provider, plugin]) => ({
+      provider,
+      description: plugin.manifest.description,
+      active: this.activeProviders.has(provider)
+    }));
+  }
   async activateForSkill(skill) {
     if (!skill.pluginProvider) {
       return false;
@@ -2452,8 +2232,9 @@ var McpToolManager = class {
       throw firstError;
     }
   }
-  getActiveToolCatalog(skills, options = {}) {
-    return this.getResolvedActiveTools(skills, options).map(
+  /** Return descriptors for all active MCP provider tools, optionally filtered by provider. */
+  getActiveToolCatalog(options = {}) {
+    return this.getResolvedActiveTools(options).map(
       (tool2) => this.toToolDescriptor(tool2)
     );
   }
@@ -2573,30 +2354,17 @@ var McpToolManager = class {
     this.activeProviders.delete(provider);
     return true;
   }
-  /** Return all active ManagedMcpTool objects for the given skill scope. */
-  getResolvedActiveTools(skills, options = {}) {
+  /** Return all active ManagedMcpTool objects, optionally filtered by provider. */
+  getResolvedActiveTools(options = {}) {
     const resolved = [];
     for (const provider of this.getActiveProviders()) {
       if (options.provider && provider !== options.provider) {
         continue;
       }
-      resolved.push(...this.resolveProviderTools(provider, skills));
+      resolved.push(...this.toolsByProvider.get(provider) ?? []);
     }
     return resolved;
   }
-  resolveProviderTools(provider, skills) {
-    const providerTools = this.toolsByProvider.get(provider) ?? [];
-    if (providerTools.length === 0) {
-      return [];
-    }
-    const relevantSkills = skills.filter(
-      (skill) => skill.pluginProvider === provider
-    );
-    if (relevantSkills.length === 0) {
-      return [];
-    }
-    return providerTools;
-  }
   toToolDescriptor(tool2) {
     return {
       name: tool2.name,
@@ -2614,6 +2382,136 @@ function toOptionalRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 
+// src/chat/mcp/tool-name.ts
+function parseMcpProviderFromToolName(toolName) {
+  if (!toolName.startsWith("mcp__")) return void 0;
+  const afterPrefix = toolName.slice("mcp__".length);
+  const delimiterIndex = afterPrefix.indexOf("__");
+  return delimiterIndex > 0 ? afterPrefix.slice(0, delimiterIndex) : void 0;
+}
+
+// src/chat/pi/derived-state.ts
+var MCP_BRIDGE_TOOLS = /* @__PURE__ */ new Set(["callMcpTool", "searchMcpTools"]);
+function isRecord3(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function providerFromToolName(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  return parseMcpProviderFromToolName(value);
+}
+function addString(values, value) {
+  if (typeof value === "string" && value.trim()) {
+    values.add(value.trim());
+  }
+}
+function getToolName(value) {
+  return typeof value.toolName === "string" ? value.toolName : typeof value.name === "string" ? value.name : void 0;
+}
+function addBridgeToolProvider(toolName, value, providers) {
+  const bridgeTool = toolName && MCP_BRIDGE_TOOLS.has(toolName) ? toolName : void 0;
+  if (bridgeTool === "searchMcpTools") {
+    for (const argsKey of ["input", "args", "arguments", "params"]) {
+      const args = value[argsKey];
+      if (isRecord3(args)) {
+        addString(providers, args.provider);
+      }
+    }
+    addString(providers, value.provider);
+  }
+  if (bridgeTool === "callMcpTool") {
+    for (const argsKey of ["input", "args", "arguments", "params"]) {
+      const args = value[argsKey];
+      if (isRecord3(args)) {
+        addString(providers, providerFromToolName(args.tool_name));
+      }
+    }
+    addString(providers, providerFromToolName(value.tool_name));
+  }
+}
+function addMcpResultProvider(message, providers) {
+  const toolName = typeof message.toolName === "string" ? message.toolName : void 0;
+  if (message.isError === true) {
+    return;
+  }
+  if (toolName === "loadSkill") {
+    if (isRecord3(message.details)) {
+      addString(providers, message.details.mcp_provider);
+    }
+    addString(providers, message.mcp_provider);
+    return;
+  }
+  if (toolName === "searchMcpTools") {
+    if (isRecord3(message.details)) {
+      addString(providers, message.details.provider);
+      if (Array.isArray(message.details.tools)) {
+        for (const tool2 of message.details.tools) {
+          if (isRecord3(tool2)) {
+            addString(providers, providerFromToolName(tool2.tool_name));
+          }
+        }
+      }
+    }
+    addString(providers, message.provider);
+    return;
+  }
+  if (toolName === "callMcpTool") {
+    for (const argsKey of ["input", "args", "arguments", "params"]) {
+      const args = message[argsKey];
+      if (isRecord3(args)) {
+        addString(providers, providerFromToolName(args.tool_name));
+      }
+    }
+    if (isRecord3(message.details)) {
+      addString(providers, message.details.provider);
+      addString(providers, providerFromToolName(message.details.tool_name));
+    }
+    addString(providers, providerFromToolName(message.tool_name));
+  }
+}
+function scanMcpProviders(message, providers) {
+  if (!isRecord3(message)) {
+    return;
+  }
+  if (message.role === "toolResult") {
+    addMcpResultProvider(message, providers);
+    return;
+  }
+  const content = message.content;
+  if (!Array.isArray(content)) {
+    return;
+  }
+  for (const part of content) {
+    if (!isRecord3(part)) {
+      continue;
+    }
+    addBridgeToolProvider(getToolName(part), part, providers);
+  }
+}
+function scanLoadedSkills(message, skills) {
+  if (isRecord3(message) && message.role === "toolResult" && message.toolName === "loadSkill" && message.isError !== true) {
+    if (isRecord3(message.details)) {
+      addString(skills, message.details.skill_name);
+    }
+    addString(skills, message.skill_name);
+  }
+}
+function inferActiveMcpProvidersFromPiMessages(messages) {
+  const providers = /* @__PURE__ */ new Set();
+  for (const message of messages ?? []) {
+    scanMcpProviders(message, providers);
+  }
+  return [...providers].sort((left, right) => left.localeCompare(right));
+}
+function inferLoadedSkillNamesFromPiMessages(messages) {
+  const skills = /* @__PURE__ */ new Set();
+  for (const message of messages ?? []) {
+    scanLoadedSkills(message, skills);
+  }
+  return [...skills].sort((left, right) => left.localeCompare(right));
+}
+
 // src/chat/tools/definition.ts
 function tool(definition) {
   return definition;
@@ -2646,7 +2544,7 @@ function createBashTool() {
 }
 
 // src/chat/tools/sandbox/file-utils.ts
-import path4 from "path";
+import path3 from "path";
 
 // src/chat/tools/execution/tool-input-error.ts
 var ToolInputError = class extends Error {
@@ -2742,12 +2640,12 @@ function matchesGlob(relativePath, pattern) {
   if (pattern.startsWith("**/") && matchesGlob(relativePath, pattern.slice(3))) {
     return true;
   }
-  return !pattern.includes("/") && matcher.test(path4.posix.basename(relativePath));
+  return !pattern.includes("/") && matcher.test(path3.posix.basename(relativePath));
 }
 function resolveWorkspacePath(input, fallback = ".") {
   const requested = (input ?? "").trim() || fallback;
-  const absolute = requested.startsWith("/") ? requested : path4.posix.join(SANDBOX_WORKSPACE_ROOT, requested);
-  const normalized = path4.posix.normalize(absolute);
+  const absolute = requested.startsWith("/") ? requested : path3.posix.join(SANDBOX_WORKSPACE_ROOT, requested);
+  const normalized = path3.posix.normalize(absolute);
   if (normalized !== SANDBOX_WORKSPACE_ROOT && !normalized.startsWith(`${SANDBOX_WORKSPACE_ROOT}/`)) {
     throw new ToolInputError(
       `Path must stay within ${SANDBOX_WORKSPACE_ROOT}: ${requested}`
@@ -2776,7 +2674,7 @@ async function collectFiles(params) {
       throw error;
     }
     for (const entry of entries) {
-      const fullPath = path4.posix.join(dirPath, entry);
+      const fullPath = path3.posix.join(dirPath, entry);
       let stat2;
       try {
         stat2 = await params.fs.stat(fullPath);
@@ -2794,7 +2692,7 @@ async function collectFiles(params) {
         if (limitReached) return;
         continue;
       }
-      const relativePath = path4.posix.relative(params.root, fullPath);
+      const relativePath = path3.posix.relative(params.root, fullPath);
       if (!params.pattern || matchesGlob(relativePath, params.pattern)) {
         files.push(fullPath);
         if (params.limit && files.length >= params.limit) {
@@ -2819,7 +2717,7 @@ async function collectFiles(params) {
     throw error;
   }
   if (!stat.isDirectory()) {
-    const relativePath = path4.posix.basename(params.root);
+    const relativePath = path3.posix.basename(params.root);
     return {
       files: !params.pattern || matchesGlob(relativePath, params.pattern) ? [params.root] : [],
       limitReached: false,
@@ -3102,7 +3000,7 @@ function createEditFileTool() {
 }
 
 // src/chat/tools/sandbox/find-files.ts
-import path5 from "path";
+import path4 from "path";
 import { Type as Type3 } from "@sinclair/typebox";
 var DEFAULT_FIND_LIMIT = 1e3;
 async function findFiles(params) {
@@ -3124,7 +3022,7 @@ async function findFiles(params) {
     });
   }
   const relativePaths = files.map(
-    (filePath) => path5.posix.relative(root, filePath)
+    (filePath) => path4.posix.relative(root, filePath)
   );
   const bounded = truncateText(
     relativePaths.length > 0 ? relativePaths.join("\n") : "No files found matching pattern"
@@ -3189,7 +3087,7 @@ function createFindFilesTool() {
 }
 
 // src/chat/tools/sandbox/grep.ts
-import path6 from "path";
+import path5 from "path";
 import { Type as Type4 } from "@sinclair/typebox";
 var DEFAULT_GREP_LIMIT = 100;
 var MAX_GREP_LINE_CHARS = 500;
@@ -3261,7 +3159,7 @@ async function grepFiles(params) {
       continue;
     }
     const lines = normalizeToLf(content).split("\n");
-    const relativePath = files.length === 1 && filePath === root ? path6.posix.basename(filePath) : path6.posix.relative(root, filePath);
+    const relativePath = files.length === 1 && filePath === root ? path5.posix.basename(filePath) : path5.posix.relative(root, filePath);
     const matchedLines = [];
     for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
       if (!lineMatches({
@@ -3388,7 +3286,7 @@ function createGrepTool() {
 }
 
 // src/chat/tools/sandbox/attach-file.ts
-import path7 from "path";
+import path6 from "path";
 import { Type as Type5 } from "@sinclair/typebox";
 var MAX_ATTACH_FILE_BYTES = 10 * 1024 * 1024;
 var MIME_BY_EXTENSION = {
@@ -3410,20 +3308,20 @@ function normalizeSandboxPath(inputPath) {
   if (!trimmed) {
     throw new Error("path is required");
   }
-  if (path7.posix.isAbsolute(trimmed)) {
+  if (path6.posix.isAbsolute(trimmed)) {
     return trimmed;
   }
-  return path7.posix.join(SANDBOX_WORKSPACE_ROOT, trimmed);
+  return path6.posix.join(SANDBOX_WORKSPACE_ROOT, trimmed);
 }
 function sanitizeFilename(value, fallbackPath) {
   const candidate = (value ?? "").trim();
   if (candidate) {
-    const base = path7.posix.basename(candidate);
+    const base = path6.posix.basename(candidate);
     if (base && base !== "." && base !== "..") {
       return base;
     }
   }
-  const derived = path7.posix.basename(fallbackPath);
+  const derived = path6.posix.basename(fallbackPath);
   if (derived && derived !== "." && derived !== "..") {
     return derived;
   }
@@ -3434,7 +3332,7 @@ function inferMimeType(filename, explicitMimeType) {
   if (explicit) {
     return explicit;
   }
-  const ext = path7.extname(filename).toLowerCase();
+  const ext = path6.extname(filename).toLowerCase();
   return MIME_BY_EXTENSION[ext] ?? "application/octet-stream";
 }
 async function detectMimeType(sandbox, targetPath) {
@@ -3481,7 +3379,7 @@ function createAttachFileTool(sandbox, hooks = {}) {
       const fileBuffer = await sandbox.readFileToBuffer({ path: targetPath });
       if (!fileBuffer) {
         const generatedFile = hooks.getGeneratedFile?.(
-          path7.posix.basename(targetPath)
+          path6.posix.basename(targetPath)
         );
         if (generatedFile) {
           hooks.onGeneratedFiles?.([generatedFile]);
@@ -3529,7 +3427,7 @@ function createAttachFileTool(sandbox, hooks = {}) {
 }
 
 // src/chat/tools/sandbox/list-dir.ts
-import path8 from "path";
+import path7 from "path";
 import { Type as Type6 } from "@sinclair/typebox";
 var DEFAULT_LIST_LIMIT = 500;
 async function listDir(params) {
@@ -3565,7 +3463,7 @@ async function listDir(params) {
       entryLimitReached = true;
       break;
     }
-    const entryPath = path8.posix.join(dirPath, entry);
+    const entryPath = path7.posix.join(dirPath, entry);
     try {
       const entryStat = await params.fs.stat(entryPath);
       output.push(`${entry}${entryStat.isDirectory() ? "/" : ""}`);
@@ -3805,9 +3703,9 @@ function resolveMcpArguments(input) {
   }
   return {};
 }
-function createCallMcpToolTool(mcpToolManager, getActiveSkills) {
+function createCallMcpToolTool(mcpToolManager) {
   return tool({
-    description: "Call an active MCP tool by exact tool_name. Use loadSkill to activate the provider, then searchMcpTools to discover tool names and schemas; copy required provider fields into arguments. Do not call with only tool_name unless the discovered tool has no arguments. Authorization is handled by the runtime when required.",
+    description: "Call an active MCP tool by exact tool_name. Use searchMcpTools to discover tool names and schemas; copy required provider fields into arguments. Do not call with only tool_name unless the discovered tool has no arguments. Authorization is handled by the runtime when required.",
     inputSchema: Type8.Object(
       {
         tool_name: Type8.String({
@@ -3824,7 +3722,11 @@ function createCallMcpToolTool(mcpToolManager, getActiveSkills) {
     ),
     execute: async (input) => {
       const { tool_name } = input;
-      const mcpTool = mcpToolManager.getResolvedActiveTools(getActiveSkills()).find((candidate) => candidate.name === tool_name);
+      const provider = parseMcpProviderFromToolName(tool_name);
+      if (provider) {
+        await mcpToolManager.activateProvider(provider);
+      }
+      const mcpTool = mcpToolManager.getResolvedActiveTools().find((candidate) => candidate.name === tool_name);
       if (!mcpTool) {
         throw new Error(`MCP tool is not active for this turn: ${tool_name}`);
       }
@@ -4073,6 +3975,33 @@ function scoreTool(toolDef, query) {
   }
   return score;
 }
+function scoreProvider(provider, query) {
+  const normalizedQuery = normalize(query);
+  if (!normalizedQuery) {
+    return 0;
+  }
+  const normalizedName = normalize(provider.provider);
+  const text = normalize([provider.provider, provider.description].join(" "));
+  let score = 0;
+  if (normalizedName === normalizedQuery) {
+    score += 100;
+  }
+  if (normalizedName.includes(normalizedQuery)) {
+    score += 50;
+  }
+  if (text.includes(normalizedQuery)) {
+    score += 25;
+  }
+  for (const term of normalizedQuery.split(/\s+/).filter(Boolean)) {
+    if (normalizedName.includes(term)) {
+      score += 12;
+    }
+    if (text.includes(term)) {
+      score += 4;
+    }
+  }
+  return score;
+}
 function searchMcpCatalog(tools, query) {
   if (!normalize(query)) {
     return [...tools].sort(
@@ -4091,9 +4020,28 @@ function searchMcpCatalog(tools, query) {
     return left.tool.name.localeCompare(right.tool.name);
   }).map((ranked) => ranked.tool);
 }
-function createSearchMcpToolsTool(mcpToolManager, getActiveSkills) {
+function searchProviderCatalog(providers, query) {
+  const sorted = [...providers].sort(
+    (left, right) => left.provider.localeCompare(right.provider)
+  );
+  if (!normalize(query)) {
+    return sorted;
+  }
+  return sorted.map(
+    (provider) => ({
+      provider,
+      score: scoreProvider(provider, query)
+    })
+  ).filter((ranked) => ranked.score > 0).sort((left, right) => {
+    if (right.score !== left.score) {
+      return right.score - left.score;
+    }
+    return left.provider.provider.localeCompare(right.provider.provider);
+  }).map((ranked) => ranked.provider);
+}
+function createSearchMcpToolsTool(mcpToolManager) {
   return tool({
-    description: "List or search active MCP tools and return full descriptors, including input/output schemas and annotations. Use after loadSkill when choosing a provider tool or when callMcpTool arguments are unclear.",
+    description: "List or search MCP providers and active MCP tools. When provider is supplied and not yet active, Junior connects to it on demand and returns tool descriptors including schemas. Without provider, returns active tools plus matching configured providers without connecting. Use when choosing a provider tool or when callMcpTool arguments are unclear.",
     inputSchema: Type10.Object(
       {
         query: Type10.Optional(
@@ -4105,7 +4053,7 @@ function createSearchMcpToolsTool(mcpToolManager, getActiveSkills) {
         provider: Type10.Optional(
           Type10.String({
             minLength: 1,
-            description: "Optional provider name to list or search within."
+            description: "Optional provider name to list or search within. If configured but not yet connected, Junior activates it on demand."
           })
         ),
         max_results: Type10.Optional(
@@ -4119,8 +4067,10 @@ function createSearchMcpToolsTool(mcpToolManager, getActiveSkills) {
       { additionalProperties: false }
     ),
     execute: async ({ query, provider, max_results }) => {
+      if (provider) {
+        await mcpToolManager.activateProvider(provider);
+      }
       const catalog = mcpToolManager.getActiveToolCatalog(
-        getActiveSkills(),
         provider ? { provider } : {}
       );
       const maxResults = max_results ?? DEFAULT_MAX_RESULTS;
@@ -4128,11 +4078,16 @@ function createSearchMcpToolsTool(mcpToolManager, getActiveSkills) {
         0,
         maxResults
       );
+      const providers = provider ? [] : searchProviderCatalog(
+        mcpToolManager.getAvailableProviderCatalog(),
+        query ?? ""
+      ).slice(0, maxResults);
       return {
         query: query ?? null,
         provider: provider ?? null,
         total_active_tools: catalog.length,
         returned_tools: matches.length,
+        available_providers: providers,
         tools: matches.map(toExposedToolSummary)
       };
     }
@@ -4167,11 +4122,11 @@ function sliceFileContent(params) {
     } : {}
   };
 }
-function missingFileResult(path11) {
+function missingFileResult(path10) {
   return {
     content: "",
     error: "not_found",
-    path: path11,
+    path: path10,
     success: false
   };
 }
@@ -6745,6 +6700,18 @@ function refreshRuntimeTurnContext(messages, turnContextPrompt) {
     nextMessages[index] = updated;
     return nextMessages;
   }
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const content = getUserMessageContent(messages[index]);
+    if (!content) {
+      continue;
+    }
+    const nextMessages = [...messages];
+    nextMessages[index] = {
+      ...messages[index],
+      content: [{ type: "text", text: turnContextPrompt }, ...content]
+    };
+    return nextMessages;
+  }
   return [
     ...messages,
     {
@@ -6754,6 +6721,13 @@ function refreshRuntimeTurnContext(messages, turnContextPrompt) {
     }
   ];
 }
+function hasRuntimeTurnContext(messages) {
+  return messages.some(
+    (message) => getUserMessageContent(message)?.some(
+      (part) => isRuntimeTurnContextPart(part, RUNTIME_TURN_CONTEXT_START)
+    )
+  );
+}
 function stripRuntimeTurnContext(messages) {
   return messages.flatMap((message) => {
     const content = getUserMessageContent(message);
@@ -6808,9 +6782,11 @@ function trimTrailingAssistantMessages(messages) {
   return end === messages.length ? [...messages] : messages.slice(0, end);
 }
 
+// src/chat/state/ttl.ts
+var JUNIOR_THREAD_STATE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+
 // src/chat/tools/advisor/session-store.ts
-import { THREAD_STATE_TTL_MS } from "chat";
-var ADVISOR_SESSION_TTL_MS = THREAD_STATE_TTL_MS;
+var ADVISOR_SESSION_TTL_MS = JUNIOR_THREAD_STATE_TTL_MS;
 function cloneMessages(messages) {
   return structuredClone(messages);
 }
@@ -6926,20 +6902,33 @@ function createAdvisorTool(context) {
         );
       }
       const conversationId = context.conversationId;
+      const conversationPrivacy = context.conversationPrivacy ?? "private";
+      const requestText = [
+        "<advisor-task>",
+        escapeXml(advisorQuestion),
+        "</advisor-task>",
+        "",
+        "<executor-context>",
+        escapeXml(advisorContext),
+        "</executor-context>"
+      ].join("\n");
+      const advisorInputMessage = {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: requestText
+          }
+        ]
+      };
+      const advisorInputMessagesAttribute = serializeGenAiAttribute(
+        conversationPrivacy !== "public" ? [toGenAiMessageMetadata(advisorInputMessage)] : [advisorInputMessage]
+      );
       return await withSpan(
-        "ai.invoke_advisor",
+        `invoke_agent ${context.config.modelId}`,
         "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 }],
@@ -6979,7 +6968,15 @@ function createAdvisorTool(context) {
           }
           const assistant = lastAssistantMessage(advisorAgent.state.messages);
           const newAdvisorMessages = advisorAgent.state.messages.slice(beforeMessageCount);
-          setSpanAttributes(extractGenAiUsageAttributes(...newAdvisorMessages));
+          const outputMessages = newAdvisorMessages.filter(isAssistantMessage);
+          const outputMessagesAttribute = serializeGenAiAttribute(
+            conversationPrivacy !== "public" ? outputMessages.map(toGenAiMessageMetadata) : outputMessages
+          );
+          setSpanAttributes({
+            ...outputMessagesAttribute ? { "gen_ai.output.messages": outputMessagesAttribute } : {},
+            ...toGenAiMessagesTraceAttributes("app.ai.output", outputMessages),
+            ...extractGenAiUsageAttributes(...newAdvisorMessages)
+          });
           if (!assistant || assistant.stopReason === "error" || assistant.stopReason === "aborted") {
             setSpanStatus("error");
             return failure(
@@ -7001,9 +6998,17 @@ function createAdvisorTool(context) {
           return success(memo);
         },
         {
-          "gen_ai.provider.name": "vercel-ai-gateway",
+          "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
           "gen_ai.operation.name": "invoke_agent",
-          "gen_ai.request.model": context.config.modelId
+          "gen_ai.request.model": context.config.modelId,
+          "gen_ai.output.type": "text",
+          "server.address": GEN_AI_SERVER_ADDRESS,
+          "server.port": GEN_AI_SERVER_PORT,
+          "app.conversation.privacy": conversationPrivacy,
+          ...toGenAiMessagesTraceAttributes("app.ai.input", [
+            advisorInputMessage
+          ]),
+          ...advisorInputMessagesAttribute ? { "gen_ai.input.messages": advisorInputMessagesAttribute } : {}
         }
       );
     }
@@ -7743,15 +7748,9 @@ function createTools(availableSkills, hooks = {}, context) {
   if (context.advisor) {
     tools.advisor = createAdvisorTool(context.advisor);
   }
-  if (context.mcpToolManager && context.getActiveSkills) {
-    tools.searchMcpTools = createSearchMcpToolsTool(
-      context.mcpToolManager,
-      context.getActiveSkills
-    );
-    tools.callMcpTool = createCallMcpToolTool(
-      context.mcpToolManager,
-      context.getActiveSkills
-    );
+  if (context.mcpToolManager) {
+    tools.searchMcpTools = createSearchMcpToolsTool(context.mcpToolManager);
+    tools.callMcpTool = createCallMcpToolTool(context.mcpToolManager);
   }
   const { channelCapabilities } = context;
   if (channelCapabilities.canCreateCanvas) {
@@ -7796,49 +7795,73 @@ function resolveChannelCapabilities(channelId) {
 import {
   streamSimple
 } from "@earendil-works/pi-ai";
-function buildChatStartAttributes(model, context) {
+function attributeModeForPrivacy(conversationPrivacy) {
+  return conversationPrivacy === "public" ? "content" : "metadata";
+}
+function buildChatStartAttributes(model, context, mode, conversationPrivacy) {
   const attributes = {
     "gen_ai.operation.name": "chat",
     "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
-    "gen_ai.request.model": model.id
+    "gen_ai.request.model": model.id,
+    "gen_ai.request.stream": true,
+    "gen_ai.output.type": "text",
+    "server.address": GEN_AI_SERVER_ADDRESS,
+    "server.port": GEN_AI_SERVER_PORT,
+    ...conversationPrivacy ? { "app.conversation.privacy": conversationPrivacy } : {},
+    ...toGenAiMessagesTraceAttributes("app.ai.input", context.messages)
   };
-  const inputMessages = serializeGenAiAttribute(context.messages);
+  const inputMessages = serializeGenAiAttribute(
+    mode === "metadata" ? context.messages.map(toGenAiMessageMetadata) : context.messages
+  );
   if (inputMessages) {
     attributes["gen_ai.input.messages"] = inputMessages;
   }
   if (context.systemPrompt) {
     const systemInstructions = serializeGenAiAttribute([
-      { type: "text", content: context.systemPrompt }
+      mode === "metadata" ? toGenAiTextMetadata(context.systemPrompt) : { type: "text", content: context.systemPrompt }
     ]);
     if (systemInstructions) {
       attributes["gen_ai.system_instructions"] = systemInstructions;
     }
+    attributes["app.ai.system_instructions.content_chars"] = context.systemPrompt.length;
   }
   return attributes;
 }
-function buildChatEndAttributes(message) {
-  const attributes = {};
-  const outputMessages = serializeGenAiAttribute([message]);
+function buildChatEndAttributes(message, mode) {
+  const attributes = {
+    ...toGenAiMessagesTraceAttributes("app.ai.output", [message])
+  };
+  const outputMessages = serializeGenAiAttribute(
+    mode === "metadata" ? [toGenAiMessageMetadata(message)] : [message]
+  );
   if (outputMessages) {
     attributes["gen_ai.output.messages"] = outputMessages;
   }
   Object.assign(attributes, extractGenAiUsageAttributes(message));
   if (message.stopReason) {
-    attributes["gen_ai.response.finish_reasons"] = [message.stopReason];
+    attributes["gen_ai.response.finish_reasons"] = [
+      normalizeGenAiFinishReason(message.stopReason)
+    ];
   }
   if (message.model) {
     attributes["gen_ai.response.model"] = message.model;
   }
   return attributes;
 }
-function createTracedStreamFn(base = streamSimple) {
+function createTracedStreamFn(baseOrOptions = streamSimple) {
+  const base = typeof baseOrOptions === "function" ? baseOrOptions : baseOrOptions.base ?? streamSimple;
+  const mode = attributeModeForPrivacy(
+    typeof baseOrOptions === "function" ? void 0 : baseOrOptions.conversationPrivacy
+  );
+  const conversationPrivacy = typeof baseOrOptions === "function" ? void 0 : baseOrOptions.conversationPrivacy;
+  const effectivePrivacy = conversationPrivacy ?? "private";
   return async (model, context, options) => {
     const span = sentry_exports.startInactiveSpan({
       name: `chat ${model.id}`,
       op: "gen_ai.chat",
       attributes: {
         ...getLogContextAttributes(),
-        ...buildChatStartAttributes(model, context)
+        ...buildChatStartAttributes(model, context, mode, effectivePrivacy)
       }
     });
     try {
@@ -7850,7 +7873,7 @@ function createTracedStreamFn(base = streamSimple) {
         (finalMessage) => {
           try {
             for (const [key, value] of Object.entries(
-              buildChatEndAttributes(finalMessage)
+              buildChatEndAttributes(finalMessage, mode)
             )) {
               span.setAttribute(key, value);
             }
@@ -8198,8 +8221,8 @@ function sandboxProxyUrl(requesterToken) {
       "Cannot determine base URL for sandbox credential egress (set JUNIOR_BASE_URL or deploy to Vercel)"
     );
   }
-  const path11 = requesterToken ? `${SANDBOX_EGRESS_PROXY_PATH}/${requesterToken}` : SANDBOX_EGRESS_PROXY_PATH;
-  return new URL(path11, baseUrl).toString();
+  const path10 = requesterToken ? `${SANDBOX_EGRESS_PROXY_PATH}/${requesterToken}` : SANDBOX_EGRESS_PROXY_PATH;
+  return new URL(path10, baseUrl).toString();
 }
 function buildSandboxEgressNetworkPolicy(input) {
   const allow = {
@@ -8447,9 +8470,9 @@ import { createBashTool as createBashTool2 } from "bash-tool";
 
 // src/chat/sandbox/skill-sync.ts
 import fs3 from "fs/promises";
-import path9 from "path";
+import path8 from "path";
 function toPosixRelative(base, absolute) {
-  return path9.relative(base, absolute).split(path9.sep).join("/");
+  return path8.relative(base, absolute).split(path8.sep).join("/");
 }
 async function listFilesRecursive(root) {
   const queue = [root];
@@ -8459,7 +8482,7 @@ async function listFilesRecursive(root) {
     const entries = await fs3.readdir(dir, { withFileTypes: true });
     entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
-      const absolute = path9.join(dir, entry.name);
+      const absolute = path8.join(dir, entry.name);
       if (entry.isDirectory()) {
         queue.push(absolute);
       } else if (entry.isFile()) {
@@ -8498,7 +8521,7 @@ async function buildSkillSyncFiles(availableSkills, referenceFiles) {
   });
   if (referenceFiles && referenceFiles.length > 0) {
     for (const absoluteFile of referenceFiles) {
-      const fileName = path9.basename(absoluteFile);
+      const fileName = path8.basename(absoluteFile);
       filesToWrite.push({
         path: `${SANDBOX_DATA_ROOT}/${fileName}`,
         content: await fs3.readFile(absoluteFile)
@@ -8510,7 +8533,7 @@ async function buildSkillSyncFiles(availableSkills, referenceFiles) {
 function collectDirectories(filesToWrite, workspaceRoot) {
   const directoriesToEnsure = /* @__PURE__ */ new Set();
   for (const file of filesToWrite) {
-    const normalizedPath = path9.posix.normalize(file.path);
+    const normalizedPath = path8.posix.normalize(file.path);
     const parts = normalizedPath.split("/").filter(Boolean);
     let current = "";
     for (let index = 0; index < parts.length - 1; index += 1) {
@@ -8523,19 +8546,19 @@ function collectDirectories(filesToWrite, workspaceRoot) {
   ).sort((a, b) => a.length - b.length);
 }
 function resolveHostSkillPath(availableSkills, sandboxPath) {
-  const normalizedPath = path9.posix.normalize(sandboxPath.trim());
+  const normalizedPath = path8.posix.normalize(sandboxPath.trim());
   for (const skill of availableSkills) {
     const virtualRoot = sandboxSkillDir(skill.name);
     if (normalizedPath !== virtualRoot && !normalizedPath.startsWith(`${virtualRoot}/`)) {
       continue;
     }
-    const relativePath = path9.posix.relative(virtualRoot, normalizedPath);
+    const relativePath = path8.posix.relative(virtualRoot, normalizedPath);
     if (!relativePath || relativePath.startsWith("../")) {
       return null;
     }
-    const hostRoot = path9.resolve(skill.skillPath);
-    const hostPath = path9.resolve(hostRoot, ...relativePath.split("/"));
-    if (hostPath !== hostRoot && !hostPath.startsWith(`${hostRoot}${path9.sep}`)) {
+    const hostRoot = path8.resolve(skill.skillPath);
+    const hostPath = path8.resolve(hostRoot, ...relativePath.split("/"));
+    if (hostPath !== hostRoot && !hostPath.startsWith(`${hostRoot}${path8.sep}`)) {
       return null;
     }
     return hostPath;
@@ -8543,16 +8566,16 @@ function resolveHostSkillPath(availableSkills, sandboxPath) {
   return null;
 }
 function resolveHostDataPath(referenceFiles, sandboxPath) {
-  const normalizedPath = path9.posix.normalize(sandboxPath.trim());
+  const normalizedPath = path8.posix.normalize(sandboxPath.trim());
   if (normalizedPath !== SANDBOX_DATA_ROOT && !normalizedPath.startsWith(`${SANDBOX_DATA_ROOT}/`)) {
     return null;
   }
-  const relativePath = path9.posix.relative(SANDBOX_DATA_ROOT, normalizedPath);
+  const relativePath = path8.posix.relative(SANDBOX_DATA_ROOT, normalizedPath);
   if (!relativePath || relativePath.startsWith("../") || relativePath.includes("/")) {
     return null;
   }
   for (const hostFile of referenceFiles) {
-    if (path9.basename(hostFile) === relativePath) {
+    if (path8.basename(hostFile) === relativePath) {
       return hostFile;
     }
   }
@@ -8790,6 +8813,12 @@ function createSandboxSessionManager(options) {
       "app.sandbox.recovery.attempted": true,
       "app.sandbox.recovery.source": source
     });
+    logWarn(
+      "sandbox_unavailable_recreating",
+      traceContext,
+      { "app.sandbox.recovery.source": source },
+      "Sandbox unavailable; recreating"
+    );
     clearSession();
     const replacement = await createFreshSandbox();
     setSpanAttributes({
@@ -8929,6 +8958,15 @@ function createSandboxSessionManager(options) {
       } : {},
       ...dependencyProfileHash ? { "app.sandbox.current_profile_hash": dependencyProfileHash } : {}
     });
+    logInfo(
+      "sandbox_hint_discarded_profile_mismatch",
+      traceContext,
+      {
+        ...options?.sandboxDependencyProfileHash ? { "app.sandbox.previous_profile_hash": options.sandboxDependencyProfileHash } : {},
+        ...dependencyProfileHash ? { "app.sandbox.current_profile_hash": dependencyProfileHash } : {}
+      },
+      "Dependency profile changed; discarding sandbox hint and creating fresh session"
+    );
     sandboxIdHint = void 0;
   };
   const tryReuseCachedSandbox = async () => {
@@ -8970,7 +9008,16 @@ function createSandboxSessionManager(options) {
           })
         )
       );
-    } catch {
+    } catch (error) {
+      logWarn(
+        "sandbox_restore_hint_failed",
+        traceContext,
+        {
+          "app.sandbox.hint_id": sandboxIdHint,
+          "app.sandbox.error": error instanceof Error ? error.message : String(error)
+        },
+        "Failed to restore sandbox from hint; will create fresh session"
+      );
       return null;
     }
     try {
@@ -9786,6 +9833,9 @@ function normalizeToolResult(result, isSandboxResult) {
 // src/chat/tools/execution/tool-error-handler.ts
 import { AgentPluginToolInputError } from "@sentry/junior-plugin-api";
 
+// src/chat/services/plugin-auth-orchestration.ts
+import { THREAD_STATE_TTL_MS } from "chat";
+
 // src/chat/mcp/auth-store.ts
 var MCP_AUTH_SESSION_PREFIX = "junior:mcp_auth_session";
 var MCP_AUTH_CREDENTIALS_PREFIX = "junior:mcp_auth_credentials";
@@ -10048,317 +10098,6 @@ function buildDeterministicTurnId(messageId) {
   return `turn_${sanitized}`;
 }
 
-// src/chat/state/turn-session-store.ts
-import { THREAD_STATE_TTL_MS as THREAD_STATE_TTL_MS2 } from "chat";
-
-// src/chat/state/pi-session-message-store.ts
-import { isDeepStrictEqual } from "util";
-var PI_SESSION_MESSAGE_PREFIX = "junior:pi_session_message";
-function piSessionMessageKey(scope, index) {
-  return `${PI_SESSION_MESSAGE_PREFIX}:${scope.conversationId}:${scope.sessionId}:${index}`;
-}
-function parsePiMessage(value) {
-  return isRecord(value) ? value : void 0;
-}
-function normalizeMessageCount(value) {
-  return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
-}
-function countMatchingPrefix(left, right) {
-  const limit = Math.min(left.length, right.length);
-  for (let index = 0; index < limit; index += 1) {
-    if (!isDeepStrictEqual(left[index], right[index])) {
-      return index;
-    }
-  }
-  return limit;
-}
-async function loadPiSessionMessages(args) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const messageCount = normalizeMessageCount(args.messageCount);
-  if (messageCount === 0) {
-    return [];
-  }
-  const values = await Promise.all(
-    Array.from(
-      { length: messageCount },
-      (_, index) => stateAdapter.get(piSessionMessageKey(args, index))
-    )
-  );
-  const messages = [];
-  for (const value of values) {
-    const message = parsePiMessage(value);
-    if (!message) {
-      break;
-    }
-    messages.push(message);
-  }
-  return messages.length === messageCount ? messages : void 0;
-}
-async function loadExistingPiSessionMessages(scope, maxCount) {
-  const count = normalizeMessageCount(maxCount);
-  if (count === 0) {
-    return [];
-  }
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const values = await Promise.all(
-    Array.from(
-      { length: count },
-      (_, index) => stateAdapter.get(piSessionMessageKey(scope, index))
-    )
-  );
-  const messages = [];
-  for (const value of values) {
-    const message = parsePiMessage(value);
-    if (!message) {
-      break;
-    }
-    messages.push(message);
-  }
-  return messages;
-}
-async function commitPiSessionMessages(args) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const existingMessages = await loadExistingPiSessionMessages(
-    { conversationId: args.conversationId, sessionId: args.sessionId },
-    args.messages.length
-  );
-  const writeFromIndex = countMatchingPrefix(existingMessages, args.messages);
-  await Promise.all(
-    args.messages.slice(writeFromIndex).map(
-      (message, offset) => stateAdapter.set(
-        piSessionMessageKey(args, writeFromIndex + offset),
-        message,
-        args.ttlMs
-      )
-    )
-  );
-}
-
-// src/chat/state/turn-session-store.ts
-var AGENT_TURN_SESSION_PREFIX = "junior:agent_turn_session";
-var AGENT_TURN_SESSION_TTL_MS = THREAD_STATE_TTL_MS2;
-function agentTurnSessionKey(conversationId, sessionId) {
-  return `${AGENT_TURN_SESSION_PREFIX}:${conversationId}:${sessionId}`;
-}
-function toFiniteNonNegativeNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : void 0;
-}
-function parseAgentTurnUsage(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const usage = {};
-  for (const field of [
-    "inputTokens",
-    "outputTokens",
-    "cachedInputTokens",
-    "cacheCreationTokens",
-    "totalTokens"
-  ]) {
-    const count = toFiniteNonNegativeNumber(value[field]);
-    if (count !== void 0) {
-      usage[field] = count;
-    }
-  }
-  return Object.keys(usage).length > 0 ? usage : void 0;
-}
-function parseStoredRecord(value) {
-  if (isRecord(value)) {
-    return value;
-  }
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  try {
-    const parsed = JSON.parse(value);
-    return isRecord(parsed) ? parsed : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function parseAgentTurnSessionRecord(value) {
-  const parsed = parseStoredRecord(value);
-  if (!parsed) {
-    return void 0;
-  }
-  const status = parsed.state;
-  if (status !== "running" && status !== "awaiting_resume" && status !== "completed" && status !== "failed" && status !== "superseded") {
-    return void 0;
-  }
-  const conversationId = parsed.conversationId;
-  const sessionId = parsed.sessionId;
-  const sliceId = parsed.sliceId;
-  const checkpointVersion = parsed.checkpointVersion;
-  const updatedAtMs = parsed.updatedAtMs;
-  const cumulativeDurationMs = toFiniteNonNegativeNumber(
-    parsed.cumulativeDurationMs
-  );
-  const cumulativeUsage = parseAgentTurnUsage(parsed.cumulativeUsage);
-  if (typeof conversationId !== "string" || typeof sessionId !== "string" || typeof sliceId !== "number" || typeof checkpointVersion !== "number" || typeof updatedAtMs !== "number") {
-    return void 0;
-  }
-  const legacyPiMessages = Array.isArray(parsed.piMessages) ? parsed.piMessages : [];
-  const messageCount = toFiniteNonNegativeNumber(parsed.messageCount) ?? legacyPiMessages.length;
-  return {
-    legacyPiMessages,
-    record: {
-      checkpointVersion,
-      conversationId,
-      sessionId,
-      sliceId,
-      state: status,
-      updatedAtMs,
-      messageCount,
-      ...cumulativeDurationMs !== void 0 ? { cumulativeDurationMs } : {},
-      ...cumulativeUsage ? { cumulativeUsage } : {},
-      ...Array.isArray(parsed.loadedSkillNames) ? {
-        loadedSkillNames: parsed.loadedSkillNames.filter(
-          (value2) => typeof value2 === "string"
-        )
-      } : {},
-      ...parsed.resumeReason === "timeout" || parsed.resumeReason === "auth" ? { resumeReason: parsed.resumeReason } : {},
-      ...typeof parsed.errorMessage === "string" ? { errorMessage: parsed.errorMessage } : {},
-      ...typeof parsed.resumedFromSliceId === "number" ? { resumedFromSliceId: parsed.resumedFromSliceId } : {}
-    }
-  };
-}
-function materializePiMessages(legacyPiMessages, messageCount, sessionMessages) {
-  if (messageCount === 0) {
-    return [];
-  }
-  if (sessionMessages) {
-    return sessionMessages;
-  }
-  if (legacyPiMessages.length >= messageCount) {
-    return legacyPiMessages.slice(0, messageCount);
-  }
-  return void 0;
-}
-async function getAgentTurnSessionCheckpoint(conversationId, sessionId) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const value = await stateAdapter.get(
-    agentTurnSessionKey(conversationId, sessionId)
-  );
-  const parsed = parseAgentTurnSessionRecord(value);
-  if (!parsed) {
-    return void 0;
-  }
-  const sessionMessages = await loadPiSessionMessages({
-    conversationId,
-    sessionId,
-    messageCount: parsed.record.messageCount
-  });
-  const piMessages = materializePiMessages(
-    parsed.legacyPiMessages,
-    parsed.record.messageCount,
-    sessionMessages
-  );
-  if (!piMessages) {
-    return void 0;
-  }
-  return {
-    ...parsed.record,
-    piMessages
-  };
-}
-async function upsertAgentTurnSessionCheckpoint(args) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const existingValue = await stateAdapter.get(
-    agentTurnSessionKey(args.conversationId, args.sessionId)
-  );
-  const existingRecord = parseAgentTurnSessionRecord(existingValue);
-  const ttlMs = Math.max(1, args.ttlMs ?? AGENT_TURN_SESSION_TTL_MS);
-  await commitPiSessionMessages({
-    conversationId: args.conversationId,
-    sessionId: args.sessionId,
-    messages: args.piMessages,
-    ttlMs
-  });
-  const storedMessageCount = args.piMessages.length;
-  const checkpoint = {
-    checkpointVersion: (existingRecord?.record.checkpointVersion ?? 0) + 1,
-    conversationId: args.conversationId,
-    sessionId: args.sessionId,
-    sliceId: args.sliceId,
-    state: args.state,
-    updatedAtMs: Date.now(),
-    messageCount: storedMessageCount,
-    ...typeof args.cumulativeDurationMs === "number" && Number.isFinite(args.cumulativeDurationMs) ? {
-      cumulativeDurationMs: Math.max(
-        0,
-        Math.floor(args.cumulativeDurationMs)
-      )
-    } : {},
-    ...args.cumulativeUsage ? { cumulativeUsage: args.cumulativeUsage } : {},
-    ...Array.isArray(args.loadedSkillNames) ? {
-      loadedSkillNames: args.loadedSkillNames.filter(
-        (value) => typeof value === "string"
-      )
-    } : {},
-    ...args.resumeReason ? { resumeReason: args.resumeReason } : {},
-    ...args.errorMessage ? { errorMessage: args.errorMessage } : {},
-    ...typeof args.resumedFromSliceId === "number" ? { resumedFromSliceId: args.resumedFromSliceId } : {}
-  };
-  await stateAdapter.set(
-    agentTurnSessionKey(args.conversationId, args.sessionId),
-    checkpoint,
-    ttlMs
-  );
-  return {
-    ...checkpoint,
-    piMessages: [...args.piMessages]
-  };
-}
-async function supersedeAgentTurnSessionCheckpoint(args) {
-  const existing = await getAgentTurnSessionCheckpoint(
-    args.conversationId,
-    args.sessionId
-  );
-  if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "superseded") {
-    return void 0;
-  }
-  return await upsertAgentTurnSessionCheckpoint({
-    conversationId: existing.conversationId,
-    sessionId: existing.sessionId,
-    sliceId: existing.sliceId,
-    state: "superseded",
-    piMessages: existing.piMessages,
-    cumulativeDurationMs: existing.cumulativeDurationMs,
-    cumulativeUsage: existing.cumulativeUsage,
-    loadedSkillNames: existing.loadedSkillNames,
-    resumeReason: existing.resumeReason,
-    resumedFromSliceId: existing.resumedFromSliceId,
-    errorMessage: args.errorMessage ?? existing.errorMessage
-  });
-}
-async function failAgentTurnSessionCheckpoint(args) {
-  const existing = await getAgentTurnSessionCheckpoint(
-    args.conversationId,
-    args.sessionId
-  );
-  if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "superseded" || typeof args.expectedCheckpointVersion === "number" && existing.checkpointVersion !== args.expectedCheckpointVersion) {
-    return void 0;
-  }
-  return await upsertAgentTurnSessionCheckpoint({
-    conversationId: existing.conversationId,
-    sessionId: existing.sessionId,
-    sliceId: existing.sliceId,
-    state: "failed",
-    piMessages: existing.piMessages,
-    cumulativeDurationMs: existing.cumulativeDurationMs,
-    cumulativeUsage: existing.cumulativeUsage,
-    loadedSkillNames: existing.loadedSkillNames,
-    resumeReason: existing.resumeReason,
-    resumedFromSliceId: existing.resumedFromSliceId,
-    errorMessage: args.errorMessage ?? existing.errorMessage
-  });
-}
-
 // src/chat/services/pending-auth.ts
 var AUTH_LINK_REUSE_WINDOW_MS = 10 * 60 * 1e3;
 function canReusePendingAuthLink(args) {
@@ -10391,10 +10130,10 @@ async function applyPendingAuthUpdate(args) {
   const previousPendingAuth = args.conversation.processing.pendingAuth;
   args.conversation.processing.pendingAuth = args.nextPendingAuth;
   if (previousPendingAuth && previousPendingAuth.sessionId !== args.nextPendingAuth.sessionId && args.conversationId) {
-    await supersedeAgentTurnSessionCheckpoint({
+    await abandonAgentTurnSessionRecord({
       conversationId: args.conversationId,
       sessionId: previousPendingAuth.sessionId,
-      errorMessage: "Superseded by a newer auth-blocked request in the same conversation."
+      errorMessage: "Abandoned by a newer auth-blocked request in the same conversation."
     });
   }
 }
@@ -10514,6 +10253,9 @@ function formatCommand(command) {
   const collapsed = command.replace(/\s+/g, " ").trim();
   return collapsed.length > 160 ? `${collapsed.slice(0, 157)}...` : collapsed;
 }
+function authorizationId(args) {
+  return `${args.sessionId}:${args.kind}:${args.provider}`;
+}
 function buildCredentialFailureError(provider, command) {
   const providerLabel = provider === "github" ? "GitHub" : formatProviderLabel(provider);
   const plugin = getPluginDefinition(provider);
@@ -10576,6 +10318,21 @@ function createPluginAuthOrchestration(deps, abortAgent) {
         linkSentAtMs: reusingPendingLink ? deps.currentPendingAuth.linkSentAtMs : Date.now()
       });
     }
+    if (deps.conversationId && deps.sessionId) {
+      await recordAuthorizationRequested({
+        conversationId: deps.conversationId,
+        kind: "plugin",
+        provider,
+        requesterId: deps.requesterId,
+        authorizationId: authorizationId({
+          kind: "plugin",
+          provider,
+          sessionId: deps.sessionId
+        }),
+        delivery: reusingPendingLink ? "private_link_reused" : "private_link_sent",
+        ttlMs: THREAD_STATE_TTL_MS
+      });
+    }
     pendingPause = new PluginAuthorizationPauseError(
       provider,
       reusingPendingLink ? "link_already_sent" : "link_sent"
@@ -10701,8 +10458,12 @@ function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, trac
 }
 
 // src/chat/tools/agent-tools.ts
-function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor, pluginAuthOrchestration, onToolCall, agentHooks) {
+function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor, pluginAuthOrchestration, onToolCall, agentHooks, conversationPrivacy) {
   const shouldTrace = shouldEmitDevAgentTrace();
+  const effectiveConversationPrivacy = conversationPrivacy ?? "private";
+  const serializeToolPayload = (payload) => serializeGenAiAttribute(
+    effectiveConversationPrivacy === "private" ? toGenAiPayloadMetadata(payload) : payload
+  );
   return Object.entries(tools).map(([toolName, toolDef]) => ({
     name: toolName,
     label: toolName,
@@ -10712,7 +10473,11 @@ function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor
     executionMode: toolDef.executionMode,
     execute: async (toolCallId, params) => {
       const normalizedToolCallId = typeof toolCallId === "string" && toolCallId.length > 0 ? toolCallId : void 0;
-      const toolArgumentsAttribute = serializeGenAiAttribute(params);
+      const toolArgumentsAttribute = serializeToolPayload(params);
+      const toolArgumentsMetadata = toGenAiPayloadTraceAttributes(
+        "app.ai.tool.call.arguments",
+        params
+      );
       if (toolName === "reportProgress") {
         const status = buildReportedProgressStatus(params);
         if (status) {
@@ -10728,10 +10493,14 @@ function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor
           try {
             if (typeof toolDef.execute !== "function") {
               const resultDetails = { ok: true };
-              const toolResultAttribute2 = serializeGenAiAttribute(resultDetails);
+              const toolResultAttribute2 = serializeToolPayload(resultDetails);
               if (toolResultAttribute2) {
                 setSpanAttributes({
-                  "gen_ai.tool.call.result": toolResultAttribute2
+                  "gen_ai.tool.call.result": toolResultAttribute2,
+                  ...toGenAiPayloadTraceAttributes(
+                    "app.ai.tool.call.result",
+                    resultDetails
+                  )
                 });
               }
               return {
@@ -10763,10 +10532,14 @@ function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor
               });
             }
             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);
+            const toolResultAttribute = serializeToolPayload(resultAttributeValue);
             if (toolResultAttribute) {
               setSpanAttributes({
-                "gen_ai.tool.call.result": toolResultAttribute
+                "gen_ai.tool.call.result": toolResultAttribute,
+                ...toGenAiPayloadTraceAttributes(
+                  "app.ai.tool.call.result",
+                  resultAttributeValue
+                )
               });
             }
             return normalized;
@@ -10786,8 +10559,10 @@ function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor
         {
           "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
           "gen_ai.operation.name": "execute_tool",
+          "app.conversation.privacy": effectiveConversationPrivacy,
           "gen_ai.tool.name": toolName,
           "gen_ai.tool.description": toolDef.description,
+          ...toolArgumentsMetadata,
           ...normalizedToolCallId ? { "gen_ai.tool.call.id": normalizedToolCallId } : {},
           ...toolArgumentsAttribute ? { "gen_ai.tool.call.arguments": toolArgumentsAttribute } : {}
         }
@@ -10796,9 +10571,6 @@ function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor
   }));
 }
 
-// src/chat/runtime/thread-state.ts
-import { THREAD_STATE_TTL_MS as THREAD_STATE_TTL_MS3 } from "chat";
-
 // src/chat/configuration/validation.ts
 var CONFIG_KEY_RE = /^[a-z0-9]+(?:\.[a-z0-9-]+)+$/;
 var SECRET_KEY_RE = /(?:^|[_.-])(token|secret|password|passphrase|api[-_]?key|private[-_]?key|credential|auth)(?:$|[_.-])/i;
@@ -11144,7 +10916,6 @@ function coerceThreadConversationState(value) {
   const processing = {
     activeTurnId: toOptionalString(rawProcessing.activeTurnId),
     lastCompletedAtMs: toOptionalNumber(rawProcessing.lastCompletedAtMs),
-    lastSessionId: toOptionalString(rawProcessing.lastSessionId),
     pendingAuth: coercePendingAuthState(rawProcessing.pendingAuth)
   };
   const rawStats = isRecord(rawConversation.stats) ? rawConversation.stats : {};
@@ -11224,6 +10995,7 @@ function coerceThreadArtifactsState(value) {
   }
   return {
     assistantContextChannelId: typeof artifacts.assistantContextChannelId === "string" ? artifacts.assistantContextChannelId : void 0,
+    assistantTitle: typeof artifacts.assistantTitle === "string" ? artifacts.assistantTitle : void 0,
     assistantTitleSourceMessageId: typeof artifacts.assistantTitleSourceMessageId === "string" ? artifacts.assistantTitleSourceMessageId : void 0,
     lastCanvasId: typeof artifacts.lastCanvasId === "string" ? artifacts.lastCanvasId : void 0,
     lastCanvasUrl: typeof artifacts.lastCanvasUrl === "string" ? artifacts.lastCanvasUrl : void 0,
@@ -11322,7 +11094,11 @@ async function persistThreadStateById(threadId, patch) {
   await stateAdapter.connect();
   const key = threadStateKey(threadId);
   const existing = await stateAdapter.get(key) ?? {};
-  await stateAdapter.set(key, { ...existing, ...payload }, THREAD_STATE_TTL_MS3);
+  await stateAdapter.set(
+    key,
+    { ...existing, ...payload },
+    JUNIOR_THREAD_STATE_TTL_MS
+  );
 }
 function getChannelConfigurationService(thread) {
   const channel = thread.channel;
@@ -11346,7 +11122,7 @@ function getChannelConfigurationServiceById(channelId) {
       await stateAdapter.set(
         key,
         { ...existing, configuration: state },
-        THREAD_STATE_TTL_MS3
+        JUNIOR_THREAD_STATE_TTL_MS
       );
     }
   });
@@ -11389,7 +11165,6 @@ function markTurnClosed(args) {
 }
 function markTurnCompleted(args) {
   clearActiveTurn(args.conversation, args.sessionId);
-  args.conversation.processing.lastSessionId = args.sessionId;
   args.conversation.processing.lastCompletedAtMs = args.nowMs;
   args.updateConversationStats(args.conversation);
 }
@@ -11931,8 +11706,8 @@ function addAgentTurnUsage(...usages) {
   return hasAgentTurnUsage(components) ? components : void 0;
 }
 
-// src/chat/services/turn-checkpoint.ts
-function logCheckpointError(error, eventName, args, attributes, message) {
+// src/chat/services/turn-session-record.ts
+function logSessionRecordError(error, eventName, args, attributes, message) {
   logException(
     error,
     eventName,
@@ -11965,171 +11740,201 @@ function isContinuableBoundary(messages) {
   const lastRole = getPiMessageRole(messages.at(-1));
   return lastRole === "user" || lastRole === "toolResult";
 }
-async function loadTurnCheckpoint(ctx) {
+function resumableBoundary(messages, fallbackMessages) {
+  const current = trimTrailingAssistantMessages(messages);
+  if (current.length > 0 && isContinuableBoundary(current)) {
+    return current;
+  }
+  return trimTrailingAssistantMessages(fallbackMessages ?? []);
+}
+async function loadTurnSessionRecord(ctx) {
   const canUseTurnSession = Boolean(ctx.conversationId && ctx.sessionId);
-  const existingCheckpoint = canUseTurnSession && ctx.conversationId && ctx.sessionId ? await getAgentTurnSessionCheckpoint(ctx.conversationId, ctx.sessionId) : void 0;
-  const hasAwaitingResumeCheckpoint = Boolean(
-    existingCheckpoint && existingCheckpoint.state === "awaiting_resume" && existingCheckpoint.piMessages.length > 0
+  const existingSessionRecord = canUseTurnSession && ctx.conversationId && ctx.sessionId ? await getAgentTurnSessionRecord(ctx.conversationId, ctx.sessionId) : void 0;
+  const hasAwaitingResumeRecord = Boolean(
+    existingSessionRecord && existingSessionRecord.state === "awaiting_resume" && existingSessionRecord.piMessages.length > 0
   );
   return {
     canUseTurnSession,
-    resumedFromCheckpoint: hasAwaitingResumeCheckpoint,
-    currentSliceId: hasAwaitingResumeCheckpoint ? existingCheckpoint.sliceId : 1,
-    existingCheckpoint
+    resumedFromSessionRecord: hasAwaitingResumeRecord,
+    currentSliceId: hasAwaitingResumeRecord ? existingSessionRecord.sliceId : 1,
+    existingSessionRecord
   };
 }
-async function persistRunningCheckpoint(args) {
+async function persistRunningSessionRecord(args) {
   if (args.messages.length === 0 || !isContinuableBoundary(args.messages)) {
     return;
   }
   try {
-    const latestCheckpoint = await getAgentTurnSessionCheckpoint(
+    const latestSessionRecord = await getAgentTurnSessionRecord(
       args.conversationId,
       args.sessionId
     );
-    await upsertAgentTurnSessionCheckpoint({
+    await upsertAgentTurnSessionRecord({
+      ...args.channelName ?? latestSessionRecord?.channelName ? { channelName: args.channelName ?? latestSessionRecord?.channelName } : {},
       conversationId: args.conversationId,
-      cumulativeDurationMs: latestCheckpoint?.cumulativeDurationMs,
-      cumulativeUsage: latestCheckpoint?.cumulativeUsage,
+      cumulativeDurationMs: latestSessionRecord?.cumulativeDurationMs,
+      cumulativeUsage: latestSessionRecord?.cumulativeUsage,
       sessionId: args.sessionId,
       sliceId: args.sliceId,
       state: "running",
       piMessages: args.messages,
-      loadedSkillNames: args.loadedSkillNames
+      ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
+      ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
+      ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {}
     });
-  } catch (checkpointError) {
-    logCheckpointError(
-      checkpointError,
-      "agent_turn_running_checkpoint_failed",
+  } catch (recordError) {
+    logSessionRecordError(
+      recordError,
+      "agent_turn_running_session_record_failed",
       args,
       {
         "app.ai.resume_slice_id": args.sliceId
       },
-      "Failed to persist running turn checkpoint"
+      "Failed to persist running turn session record"
     );
   }
 }
-async function persistCompletedCheckpoint(args) {
+async function persistCompletedSessionRecord(args) {
   try {
-    const latestCheckpoint = await getAgentTurnSessionCheckpoint(
+    const latestSessionRecord = await getAgentTurnSessionRecord(
       args.conversationId,
       args.sessionId
     );
-    await upsertAgentTurnSessionCheckpoint({
+    await upsertAgentTurnSessionRecord({
+      ...args.channelName ?? latestSessionRecord?.channelName ? { channelName: args.channelName ?? latestSessionRecord?.channelName } : {},
       conversationId: args.conversationId,
       cumulativeDurationMs: addDurationMs(
-        latestCheckpoint?.cumulativeDurationMs,
+        latestSessionRecord?.cumulativeDurationMs,
         args.currentDurationMs
       ),
       cumulativeUsage: addAgentTurnUsage(
-        latestCheckpoint?.cumulativeUsage,
+        latestSessionRecord?.cumulativeUsage,
         args.currentUsage
       ),
       sessionId: args.sessionId,
       sliceId: args.sliceId,
       state: "completed",
       piMessages: args.allMessages,
-      loadedSkillNames: args.loadedSkillNames
+      ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
+      ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
+      ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {}
     });
-  } catch (checkpointError) {
-    logCheckpointError(
-      checkpointError,
-      "agent_turn_completed_checkpoint_failed",
+  } catch (recordError) {
+    logSessionRecordError(
+      recordError,
+      "agent_turn_completed_session_record_failed",
       args,
       {
         "app.ai.resume_slice_id": args.sliceId
       },
-      "Failed to persist completed turn checkpoint"
+      "Failed to persist completed turn session record"
     );
   }
 }
-async function persistAuthPauseCheckpoint(args) {
+async function persistAuthPauseSessionRecord(args) {
   const nextSliceId = args.currentSliceId + 1;
   try {
-    const latestCheckpoint = await getAgentTurnSessionCheckpoint(
+    const latestSessionRecord = await getAgentTurnSessionRecord(
       args.conversationId,
       args.sessionId
     );
-    const piMessages = trimTrailingAssistantMessages(
-      args.messages.length > 0 ? args.messages : latestCheckpoint?.piMessages ?? []
+    const piMessages = resumableBoundary(
+      args.messages,
+      latestSessionRecord?.piMessages
     );
-    return await upsertAgentTurnSessionCheckpoint({
+    if (piMessages.length === 0 || !isContinuableBoundary(piMessages)) {
+      return void 0;
+    }
+    return await upsertAgentTurnSessionRecord({
+      ...args.channelName ?? latestSessionRecord?.channelName ? { channelName: args.channelName ?? latestSessionRecord?.channelName } : {},
       conversationId: args.conversationId,
       cumulativeDurationMs: addDurationMs(
-        latestCheckpoint?.cumulativeDurationMs,
+        latestSessionRecord?.cumulativeDurationMs,
         args.currentDurationMs
       ),
       cumulativeUsage: addAgentTurnUsage(
-        latestCheckpoint?.cumulativeUsage,
+        latestSessionRecord?.cumulativeUsage,
         args.currentUsage
       ),
       sessionId: args.sessionId,
       sliceId: nextSliceId,
       state: "awaiting_resume",
       piMessages,
-      loadedSkillNames: args.loadedSkillNames,
+      ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
       resumeReason: "auth",
       resumedFromSliceId: args.currentSliceId,
-      errorMessage: args.errorMessage
+      errorMessage: args.errorMessage,
+      ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
+      ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {}
     });
-  } catch (checkpointError) {
-    logCheckpointError(
-      checkpointError,
-      "agent_turn_auth_resume_checkpoint_failed",
+  } catch (recordError) {
+    logSessionRecordError(
+      recordError,
+      "agent_turn_auth_resume_session_record_failed",
       args,
       {
         "app.ai.resume_from_slice_id": args.currentSliceId,
         "app.ai.resume_next_slice_id": nextSliceId
       },
-      "Failed to persist auth checkpoint before retry"
+      "Failed to persist auth session record before retry"
     );
   }
   return void 0;
 }
-async function persistTimeoutCheckpoint(args) {
+async function persistTimeoutSessionRecord(args) {
   const nextSliceId = args.currentSliceId + 1;
   try {
-    const latestCheckpoint = await getAgentTurnSessionCheckpoint(
+    const latestSessionRecord = await getAgentTurnSessionRecord(
       args.conversationId,
       args.sessionId
     );
-    const piMessages = trimTrailingAssistantMessages(
-      args.messages.length > 0 ? args.messages : latestCheckpoint?.piMessages ?? []
+    const piMessages = resumableBoundary(
+      args.messages,
+      latestSessionRecord?.piMessages
     );
-    return await upsertAgentTurnSessionCheckpoint({
+    if (piMessages.length === 0 || !isContinuableBoundary(piMessages)) {
+      return void 0;
+    }
+    return await upsertAgentTurnSessionRecord({
+      ...args.channelName ?? latestSessionRecord?.channelName ? { channelName: args.channelName ?? latestSessionRecord?.channelName } : {},
       conversationId: args.conversationId,
       cumulativeDurationMs: addDurationMs(
-        latestCheckpoint?.cumulativeDurationMs,
+        latestSessionRecord?.cumulativeDurationMs,
         args.currentDurationMs
       ),
       cumulativeUsage: addAgentTurnUsage(
-        latestCheckpoint?.cumulativeUsage,
+        latestSessionRecord?.cumulativeUsage,
         args.currentUsage
       ),
       sessionId: args.sessionId,
       sliceId: nextSliceId,
       state: "awaiting_resume",
       piMessages,
-      loadedSkillNames: args.loadedSkillNames,
+      ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
       resumeReason: "timeout",
       resumedFromSliceId: args.currentSliceId,
-      errorMessage: args.errorMessage
+      errorMessage: args.errorMessage,
+      ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
+      ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {}
     });
-  } catch (checkpointError) {
-    logCheckpointError(
-      checkpointError,
-      "agent_turn_timeout_resume_checkpoint_failed",
+  } catch (recordError) {
+    logSessionRecordError(
+      recordError,
+      "agent_turn_timeout_resume_session_record_failed",
       args,
       {
         "app.ai.resume_from_slice_id": args.currentSliceId,
         "app.ai.resume_next_slice_id": nextSliceId
       },
-      "Failed to persist timeout checkpoint before scheduling resume"
+      "Failed to persist timeout session record before scheduling resume"
     );
     return void 0;
   }
 }
 
+// src/chat/services/mcp-auth-orchestration.ts
+import { THREAD_STATE_TTL_MS as THREAD_STATE_TTL_MS2 } from "chat";
+
 // src/chat/mcp/oauth.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import { StreamableHTTPClientTransport as StreamableHTTPClientTransport2 } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
@@ -12397,6 +12202,9 @@ var McpAuthorizationPauseError = class extends AuthorizationPauseError {
     super("mcp", provider, disposition);
   }
 };
+function authorizationId2(args) {
+  return `${args.sessionId}:${args.kind}:${args.provider}`;
+}
 function createMcpAuthOrchestration(deps, abortAgent) {
   let pendingPause;
   const authSessionIdsByProvider = /* @__PURE__ */ new Map();
@@ -12473,6 +12281,21 @@ function createMcpAuthOrchestration(deps, abortAgent) {
         linkSentAtMs: reusingPendingLink ? deps.currentPendingAuth.linkSentAtMs : Date.now()
       });
     }
+    if (deps.conversationId && deps.sessionId && deps.requesterId) {
+      await recordAuthorizationRequested({
+        conversationId: deps.conversationId,
+        kind: "mcp",
+        provider,
+        requesterId: deps.requesterId,
+        authorizationId: authorizationId2({
+          kind: "mcp",
+          provider,
+          sessionId: deps.sessionId
+        }),
+        delivery: reusingPendingLink ? "private_link_reused" : "private_link_sent",
+        ttlMs: THREAD_STATE_TTL_MS2
+      });
+    }
     pendingPause = new McpAuthorizationPauseError(
       provider,
       reusingPendingLink ? "link_already_sent" : "link_sent"
@@ -12517,6 +12340,15 @@ function extractSliceUsage(messages, beforeMessageCount) {
   );
   return hasAgentTurnUsage(usage) ? usage : void 0;
 }
+function requesterFromContext(requester, requesterId) {
+  const identity = {
+    ...requester?.email ? { email: requester.email } : {},
+    ...requester?.fullName ? { fullName: requester.fullName } : {},
+    ...requesterId ?? requester?.userId ? { slackUserId: requesterId ?? requester?.userId } : {},
+    ...requester?.userName ? { slackUserName: requester.userName } : {}
+  };
+  return Object.keys(identity).length > 0 ? identity : void 0;
+}
 function supportsRouterTextPreview(mediaType) {
   const baseMediaType = mediaType.split(";", 1)[0]?.trim().toLowerCase();
   if (!baseMediaType) {
@@ -12604,11 +12436,21 @@ async function generateAssistantReply(messageText2, context = {}) {
   let lastKnownSandboxDependencyProfileHash = context.sandbox?.sandboxDependencyProfileHash;
   let loadedSkillNamesForResume = [];
   let mcpToolManager;
+  let connectedMcpProviders = /* @__PURE__ */ new Set();
+  let canRecordMcpProviders = false;
   let sandboxExecutor;
   let timedOut = false;
   let turnUsage;
   let thinkingSelection;
-  const checkpointLogContext = {
+  const requester = requesterFromContext(
+    context.requester,
+    context.correlation?.requesterId
+  );
+  const conversationPrivacy = resolveConversationPrivacy({
+    channelId: context.correlation?.channelId,
+    conversationId: context.correlation?.conversationId ?? context.correlation?.threadId ?? context.correlation?.runId
+  });
+  const sessionRecordLogContext = {
     threadId: context.correlation?.threadId,
     requesterId: context.correlation?.requesterId,
     channelId: context.correlation?.channelId,
@@ -12618,6 +12460,25 @@ async function generateAssistantReply(messageText2, context = {}) {
     assistantUserName: botConfig.userName,
     modelId: botConfig.modelId
   };
+  const recordConnectedMcpProvider = async (provider) => {
+    if (!canRecordMcpProviders || !timeoutResumeConversationId || connectedMcpProviders.has(provider)) {
+      return;
+    }
+    await recordMcpProviderConnected({
+      conversationId: timeoutResumeConversationId,
+      provider,
+      ttlMs: THREAD_STATE_TTL_MS3
+    });
+    connectedMcpProviders.add(provider);
+  };
+  const recordActiveMcpProviders = async () => {
+    if (!mcpToolManager) {
+      return;
+    }
+    for (const provider of mcpToolManager.getActiveProviders()) {
+      await recordConnectedMcpProvider(provider);
+    }
+  };
   const getSandboxMetadata = () => sandboxExecutor ? {
     sandboxId: sandboxExecutor.getSandboxId(),
     sandboxDependencyProfileHash: sandboxExecutor.getDependencyProfileHash()
@@ -12685,16 +12546,22 @@ async function generateAssistantReply(messageText2, context = {}) {
     const skillInvocation = parseSkillInvocation(userInput, availableSkills);
     const invokedSkill = skillInvocation ? findSkillByName(skillInvocation.skillName, availableSkills) : null;
     const activeSkills = [];
+    const syncLoadedSkillNamesForResume = () => {
+      loadedSkillNamesForResume = activeSkills.map((skill) => skill.name);
+    };
     const skillSandbox = new SkillSandbox(availableSkills, activeSkills);
     const { conversationId: sessionConversationId, sessionId } = getSessionIdentifiers(context);
-    const checkpointState = await loadTurnCheckpoint({
+    const turnSessionState = await loadTurnSessionRecord({
       conversationId: sessionConversationId,
       sessionId
     });
-    const { resumedFromCheckpoint, currentSliceId, existingCheckpoint } = checkpointState;
+    const { resumedFromSessionRecord, currentSliceId, existingSessionRecord } = turnSessionState;
     timeoutResumeConversationId = sessionConversationId;
     timeoutResumeSessionId = sessionId;
     timeoutResumeSliceId = currentSliceId;
+    canRecordMcpProviders = Boolean(
+      turnSessionState.canUseTurnSession && sessionConversationId && sessionId
+    );
     const persistedConfigurationValues = context.channelConfiguration ? await context.channelConfiguration.resolveValues() : {};
     configurationValues = {
       ...getConfigDefaults(),
@@ -12738,6 +12605,12 @@ async function generateAssistantReply(messageText2, context = {}) {
     const currentSandboxExecutor = sandboxExecutor;
     sandboxExecutor.configureSkills(availableSkills);
     sandboxExecutor.configureReferenceFiles(listReferenceFiles());
+    const priorPiMessages = resumedFromSessionRecord ? existingSessionRecord?.piMessages : context.piMessages;
+    connectedMcpProviders = new Set(
+      turnSessionState.canUseTurnSession && sessionConversationId ? await loadConnectedMcpProviders({
+        conversationId: sessionConversationId
+      }) : []
+    );
     let sandboxPromise;
     let sandboxPromiseId;
     const clearSandboxPromise = () => {
@@ -12782,16 +12655,20 @@ async function generateAssistantReply(messageText2, context = {}) {
         cwd: input.cwd
       })).runCommand(input)
     };
-    for (const skillName of existingCheckpoint?.loadedSkillNames ?? []) {
-      const preloaded = await skillSandbox.loadSkill(skillName);
-      if (preloaded) {
-        upsertActiveSkill(activeSkills, preloaded);
+    for (const skillName of inferLoadedSkillNamesFromPiMessages(
+      priorPiMessages
+    )) {
+      const restoredSkill = await skillSandbox.loadSkill(skillName);
+      if (restoredSkill) {
+        upsertActiveSkill(activeSkills, restoredSkill);
+        syncLoadedSkillNamesForResume();
       }
     }
     if (invokedSkill) {
-      const preloaded = await skillSandbox.loadSkill(invokedSkill.name);
-      if (preloaded) {
-        upsertActiveSkill(activeSkills, preloaded);
+      const restoredSkill = await skillSandbox.loadSkill(invokedSkill.name);
+      if (restoredSkill) {
+        upsertActiveSkill(activeSkills, restoredSkill);
+        syncLoadedSkillNamesForResume();
       }
     }
     const promptConversationContext = context.piMessages && context.piMessages.length > 0 ? void 0 : context.conversationContext;
@@ -12804,6 +12681,14 @@ async function generateAssistantReply(messageText2, context = {}) {
       userAttachments: context.userAttachments,
       userTurnText
     });
+    const preAgentPromptMessages = () => existingSessionRecord?.piMessages ?? [
+      ...context.piMessages ?? [],
+      {
+        role: "user",
+        content: userContentParts,
+        timestamp: Date.now()
+      }
+    ];
     thinkingSelection = await selectTurnThinkingLevel({
       completeObject,
       conversationContext: context.conversationContext,
@@ -12872,9 +12757,6 @@ async function generateAssistantReply(messageText2, context = {}) {
     });
     const turnMcpToolManager = mcpToolManager;
     const getPendingAuthPause = () => pluginAuth.getPendingPause() ?? mcpAuth.getPendingPause();
-    const syncResumeState = () => {
-      loadedSkillNamesForResume = activeSkills.map((skill) => skill.name);
-    };
     setTags({
       conversationId: spanContext.conversationId,
       slackThreadId: context.correlation?.threadId,
@@ -12915,9 +12797,10 @@ async function generateAssistantReply(messageText2, context = {}) {
           const resolvedSkill = await skillSandbox.loadSkill(loadedSkill.name);
           const effective = resolvedSkill ?? loadedSkill;
           upsertActiveSkill(activeSkills, effective);
-          syncResumeState();
-          await turnMcpToolManager.activateForSkill(effective);
-          syncResumeState();
+          syncLoadedSkillNamesForResume();
+          if (await turnMcpToolManager.activateForSkill(effective)) {
+            await recordConnectedMcpProvider(effective.pluginProvider);
+          }
           if (mcpAuth.getPendingPause()) {
             return void 0;
           }
@@ -12927,12 +12810,9 @@ async function generateAssistantReply(messageText2, context = {}) {
           if (!turnMcpToolManager.getActiveProviders().includes(effective.pluginProvider)) {
             return void 0;
           }
-          const availableToolCount = turnMcpToolManager.getActiveToolCatalog(
-            activeSkills,
-            {
-              provider: effective.pluginProvider
-            }
-          ).length;
+          const availableToolCount = turnMcpToolManager.getActiveToolCatalog({
+            provider: effective.pluginProvider
+          }).length;
           return {
             mcp_provider: effective.pluginProvider,
             available_tool_count: availableToolCount
@@ -12949,15 +12829,15 @@ async function generateAssistantReply(messageText2, context = {}) {
         userText: userInput,
         artifactState: context.artifactState,
         configuration: configurationValues,
-        getActiveSkills: () => activeSkills,
         mcpToolManager: turnMcpToolManager,
         sandbox,
         advisor: {
           config: botConfig.advisor,
           conversationId: sessionConversationId,
+          conversationPrivacy,
           logContext: spanContext,
           getTools: () => advisorTools,
-          streamFn: createTracedStreamFn()
+          streamFn: createTracedStreamFn({ conversationPrivacy })
         }
       }
     );
@@ -12968,24 +12848,37 @@ async function generateAssistantReply(messageText2, context = {}) {
       promptGuidelines: definition.promptGuidelines,
       promptSnippet: definition.promptSnippet
     }));
-    syncResumeState();
+    const providersToRestore = /* @__PURE__ */ new Set([
+      ...connectedMcpProviders,
+      ...inferActiveMcpProvidersFromPiMessages(priorPiMessages)
+    ]);
+    for (const provider of providersToRestore) {
+      if (await turnMcpToolManager.activateProvider(provider)) {
+        await recordConnectedMcpProvider(provider);
+      }
+      if (mcpAuth.getPendingPause()) {
+        timeoutResumeMessages = preAgentPromptMessages();
+        throw mcpAuth.getPendingPause();
+      }
+    }
     for (const skill of activeSkills) {
-      await turnMcpToolManager.activateForSkill(skill);
-      syncResumeState();
+      if (await turnMcpToolManager.activateForSkill(skill)) {
+        await recordConnectedMcpProvider(skill.pluginProvider);
+      }
       if (mcpAuth.getPendingPause()) {
-        timeoutResumeMessages = existingCheckpoint?.piMessages ?? [];
+        timeoutResumeMessages = preAgentPromptMessages();
         throw mcpAuth.getPendingPause();
       }
     }
-    syncResumeState();
     const activeMcpCatalogs = toActiveMcpCatalogSummaries(
-      turnMcpToolManager.getActiveToolCatalog(activeSkills)
+      turnMcpToolManager.getActiveToolCatalog()
     );
     baseInstructions = buildSystemPrompt();
+    const includeSessionContext = resumedFromSessionRecord || !hasRuntimeTurnContext(priorPiMessages ?? []);
     const turnContextPrompt = buildTurnContextPrompt({
       availableSkills,
-      activeSkills,
       activeMcpCatalogs,
+      includeSessionContext,
       toolGuidance,
       runtime: {
         conversationId: spanContext.conversationId,
@@ -12994,14 +12887,14 @@ async function generateAssistantReply(messageText2, context = {}) {
       invocation: skillInvocation,
       requester: context.requester,
       artifactState: context.artifactState,
-      configuration: configurationValues,
-      turnState: resumedFromCheckpoint ? "resumed" : "fresh"
+      configuration: configurationValues
     });
+    const turnContextParts = turnContextPrompt ? [{ type: "text", text: turnContextPrompt }] : [];
     const promptContentParts = [
-      { type: "text", text: turnContextPrompt },
+      ...turnContextParts,
       ...userContentParts
     ];
-    const inputMessagesAttribute = serializeGenAiAttribute([
+    const inputMessages = [
       {
         role: "system",
         content: [{ type: "text", text: baseInstructions }]
@@ -13010,7 +12903,10 @@ async function generateAssistantReply(messageText2, context = {}) {
         role: "user",
         content: promptContentParts.map((part) => toObservablePromptPart(part))
       }
-    ]);
+    ];
+    const inputMessagesAttribute = serializeGenAiAttribute(
+      conversationPrivacy !== "public" ? inputMessages.map(toGenAiMessageMetadata) : inputMessages
+    );
     const onToolCall = (toolName, params) => {
       toolCalls.push(toolName);
       try {
@@ -13035,7 +12931,8 @@ async function generateAssistantReply(messageText2, context = {}) {
       sandboxExecutor,
       pluginAuth,
       onToolCall,
-      agentPluginHooks
+      agentPluginHooks,
+      conversationPrivacy
     );
     advisorTools = createAgentTools(
       createAdvisorToolDefinitions(tools),
@@ -13045,11 +12942,12 @@ async function generateAssistantReply(messageText2, context = {}) {
       sandboxExecutor,
       pluginAuth,
       onToolCall,
-      agentPluginHooks
+      agentPluginHooks,
+      conversationPrivacy
     );
     agent = new Agent2({
       getApiKey: () => getPiGatewayApiKeyOverride(),
-      streamFn: createTracedStreamFn(),
+      streamFn: createTracedStreamFn({ conversationPrivacy }),
       initialState: {
         systemPrompt: baseInstructions,
         model: resolveGatewayModel(botConfig.modelId),
@@ -13060,16 +12958,18 @@ async function generateAssistantReply(messageText2, context = {}) {
     let hasEmittedText = false;
     let needsSeparator = false;
     const persistSafeBoundary = async (messages) => {
-      if (!checkpointState.canUseTurnSession || !sessionConversationId || !sessionId) {
+      if (!turnSessionState.canUseTurnSession || !sessionConversationId || !sessionId) {
         return;
       }
-      await persistRunningCheckpoint({
+      await persistRunningSessionRecord({
+        channelName: context.correlation?.channelName,
         conversationId: sessionConversationId,
         sessionId,
         sliceId: currentSliceId,
         messages,
         loadedSkillNames: loadedSkillNamesForResume,
-        logContext: checkpointLogContext
+        logContext: sessionRecordLogContext,
+        requester
       });
     };
     const unsubscribe = agent.subscribe((event) => {
@@ -13113,17 +13013,17 @@ async function generateAssistantReply(messageText2, context = {}) {
     let newMessages = [];
     beforeMessageCount = agent.state.messages.length;
     try {
-      if (resumedFromCheckpoint) {
-        agent.state.messages = refreshRuntimeTurnContext(
-          existingCheckpoint.piMessages,
+      if (resumedFromSessionRecord) {
+        agent.state.messages = turnContextPrompt ? refreshRuntimeTurnContext(
+          existingSessionRecord.piMessages,
           turnContextPrompt
-        );
+        ) : existingSessionRecord.piMessages;
       } else if (context.piMessages && context.piMessages.length > 0) {
         agent.state.messages = [...context.piMessages];
       }
       beforeMessageCount = agent.state.messages.length;
       await withSpan(
-        "ai.generate_assistant_reply",
+        `invoke_agent ${botConfig.modelId}`,
         "gen_ai.invoke_agent",
         spanContext,
         async () => {
@@ -13133,7 +13033,7 @@ async function generateAssistantReply(messageText2, context = {}) {
             content: promptContentParts,
             timestamp: Date.now()
           };
-          if (!resumedFromCheckpoint) {
+          if (!resumedFromSessionRecord) {
             await persistSafeBoundary([
               ...agent.state.messages,
               freshPromptMessage
@@ -13185,13 +13085,15 @@ async function generateAssistantReply(messageText2, context = {}) {
               }
             }
           };
-          let run = resumedFromCheckpoint ? agent.continue() : agent.prompt(freshPromptMessage);
+          let run = resumedFromSessionRecord ? agent.continue() : agent.prompt(freshPromptMessage);
           let retryUsage;
           for (let attempt = 0; ; attempt += 1) {
             promptResult = await runAgentStep(run);
             newMessages = agent.state.messages.slice(beforeMessageCount);
             const outputMessages = newMessages.filter(isAssistantMessage);
-            const outputMessagesAttribute = serializeGenAiAttribute(outputMessages);
+            const outputMessagesAttribute = serializeGenAiAttribute(
+              conversationPrivacy !== "public" ? outputMessages.map(toGenAiMessageMetadata) : outputMessages
+            );
             const usageSummary = extractGenAiUsageSummary(
               promptResult,
               agent.state,
@@ -13201,6 +13103,10 @@ async function generateAssistantReply(messageText2, context = {}) {
             turnUsage = addAgentTurnUsage(retryUsage, currentUsage);
             setSpanAttributes({
               ...outputMessagesAttribute ? { "gen_ai.output.messages": outputMessagesAttribute } : {},
+              ...toGenAiMessagesTraceAttributes(
+                "app.ai.output",
+                outputMessages
+              ),
               ...extractGenAiUsageAttributes(usageSummary)
             });
             if (getPendingAuthPause()) {
@@ -13235,23 +13141,34 @@ async function generateAssistantReply(messageText2, context = {}) {
           "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
           "gen_ai.operation.name": "invoke_agent",
           "gen_ai.request.model": botConfig.modelId,
+          "gen_ai.output.type": "text",
+          "server.address": GEN_AI_SERVER_ADDRESS,
+          "server.port": GEN_AI_SERVER_PORT,
+          ...conversationPrivacy ? { "app.conversation.privacy": conversationPrivacy } : {},
+          ...sessionConversationId ? { "app.ai.session.conversation_id": sessionConversationId } : {},
+          ...sessionId ? { "app.ai.turn.session_id": sessionId } : {},
+          ...timeoutResumeSliceId ? { "app.ai.turn.slice_id": timeoutResumeSliceId } : {},
           "app.ai.reasoning_effort": thinkingSelection.thinkingLevel,
+          ...toGenAiMessagesTraceAttributes("app.ai.input", inputMessages),
           ...inputMessagesAttribute ? { "gen_ai.input.messages": inputMessagesAttribute } : {}
         }
       );
     } finally {
       unsubscribe();
     }
-    if (checkpointState.canUseTurnSession && sessionConversationId && sessionId) {
-      await persistCompletedCheckpoint({
+    if (turnSessionState.canUseTurnSession && sessionConversationId && sessionId) {
+      await recordActiveMcpProviders();
+      await persistCompletedSessionRecord({
+        channelName: context.correlation?.channelName,
         conversationId: sessionConversationId,
         currentDurationMs: Date.now() - replyStartedAtMs,
         currentUsage: turnUsage,
         sessionId,
         sliceId: currentSliceId,
         allMessages: agent.state.messages,
-        loadedSkillNames: activeSkills.map((skill) => skill.name),
-        logContext: checkpointLogContext
+        loadedSkillNames: loadedSkillNamesForResume,
+        logContext: sessionRecordLogContext,
+        requester
       });
     }
     return buildTurnResult({
@@ -13274,26 +13191,29 @@ async function generateAssistantReply(messageText2, context = {}) {
   } catch (error) {
     if (timedOut && timeoutResumeConversationId && timeoutResumeSessionId) {
       turnUsage = turnUsage ?? extractSliceUsage(timeoutResumeMessages, beforeMessageCount);
-      const checkpoint = await persistTimeoutCheckpoint({
+      await recordActiveMcpProviders();
+      const sessionRecord = await persistTimeoutSessionRecord({
+        channelName: context.correlation?.channelName,
         conversationId: timeoutResumeConversationId,
         sessionId: timeoutResumeSessionId,
         currentSliceId: timeoutResumeSliceId,
         currentDurationMs: Date.now() - replyStartedAtMs,
         currentUsage: turnUsage,
         messages: timeoutResumeMessages,
-        loadedSkillNames: loadedSkillNamesForResume,
         errorMessage: error instanceof Error ? error.message : String(error),
-        logContext: checkpointLogContext
+        loadedSkillNames: loadedSkillNamesForResume,
+        logContext: sessionRecordLogContext,
+        requester
       });
-      if (checkpoint) {
+      if (sessionRecord) {
         throw new RetryableTurnError(
           "turn_timeout_resume",
-          `conversation=${timeoutResumeConversationId} session=${timeoutResumeSessionId} slice=${checkpoint.sliceId} version=${checkpoint.checkpointVersion}`,
+          `conversation=${timeoutResumeConversationId} session=${timeoutResumeSessionId} slice=${sessionRecord.sliceId} version=${sessionRecord.version}`,
           {
             conversationId: timeoutResumeConversationId,
             sessionId: timeoutResumeSessionId,
-            sliceId: checkpoint.sliceId,
-            checkpointVersion: checkpoint.checkpointVersion
+            sliceId: sessionRecord.sliceId,
+            version: sessionRecord.version
           }
         );
       }
@@ -13305,21 +13225,24 @@ async function generateAssistantReply(messageText2, context = {}) {
           beforeMessageCount
         );
       }
-      const checkpoint = await persistAuthPauseCheckpoint({
+      await recordActiveMcpProviders();
+      const sessionRecord = await persistAuthPauseSessionRecord({
+        channelName: context.correlation?.channelName,
         conversationId: timeoutResumeConversationId,
         sessionId: timeoutResumeSessionId,
         currentSliceId: timeoutResumeSliceId,
         currentDurationMs: Date.now() - replyStartedAtMs,
         currentUsage: turnUsage,
         messages: timeoutResumeMessages,
-        loadedSkillNames: loadedSkillNamesForResume,
         errorMessage: error.message,
-        logContext: checkpointLogContext
+        loadedSkillNames: loadedSkillNamesForResume,
+        logContext: sessionRecordLogContext,
+        requester
       });
-      if (checkpoint) {
+      if (sessionRecord) {
         throw new RetryableTurnError(
           error.kind === "plugin" ? "plugin_auth_resume" : "mcp_auth_resume",
-          `conversation=${timeoutResumeConversationId} session=${timeoutResumeSessionId} slice=${checkpoint.sliceId}`,
+          `conversation=${timeoutResumeConversationId} session=${timeoutResumeSessionId} slice=${sessionRecord.sliceId}`,
           {
             authDisposition: error.disposition,
             authDurationMs: Date.now() - replyStartedAtMs,
@@ -13329,7 +13252,7 @@ async function generateAssistantReply(messageText2, context = {}) {
             authUsage: turnUsage,
             conversationId: timeoutResumeConversationId,
             sessionId: timeoutResumeSessionId,
-            sliceId: checkpoint.sliceId
+            sliceId: sessionRecord.sliceId
           }
         );
       }
@@ -13586,8 +13509,8 @@ async function summarizeConversationChunk(messages, conversation, context, deps)
             "Keep the summary factual and concise. Do not invent details.",
             "",
             "Output exactly three XML sections in this order:",
-            "<active-asks> one bullet per outstanding user ask that has not been narrowed, answered, or superseded by a later turn. Omit the section body if none. </active-asks>",
-            "<superseded-or-completed-asks> one bullet per ask that has been rescoped, narrowed, answered, or already acted on in this segment. Include the replacement/outcome inline. Omit the section body if none. </superseded-or-completed-asks>",
+            "<active-asks> one bullet per outstanding user ask that has not been narrowed, answered, or replaced by a later turn. Omit the section body if none. </active-asks>",
+            "<resolved-or-replaced-asks> one bullet per ask that has been replaced, narrowed, answered, or already acted on in this segment. Include the replacement/outcome inline. Omit the section body if none. </resolved-or-replaced-asks>",
             "<facts> one bullet per durable fact useful regardless of scope: names, ids, URLs, decisions, locations, preferences, constraints that remain true. Omit the section body if none. </facts>",
             "",
             "Do not output any text outside the three sections.",
@@ -13740,40 +13663,6 @@ function escapeSlackMrkdwn(text) {
 function escapeSlackLinkUrl(url) {
   return url.replaceAll("&", "&amp;").replaceAll("<", "%3C").replaceAll(">", "%3E");
 }
-function getSentryOrgSlug() {
-  const slug = process.env.SENTRY_ORG_SLUG?.trim();
-  return slug || void 0;
-}
-function isSentrySaasDsnHost(host) {
-  return host === "sentry.io" || host.endsWith(".sentry.io");
-}
-function buildSentryWebBaseUrl(dsn) {
-  if (isSentrySaasDsnHost(dsn.host)) {
-    return "https://sentry.io";
-  }
-  const port = dsn.port ? `:${dsn.port}` : "";
-  const path11 = dsn.path ? `/${dsn.path}` : "";
-  return `${dsn.protocol}://${dsn.host}${port}${path11}`;
-}
-function getSentryConversationUrl(conversationId) {
-  const client2 = sentry_exports.getClient();
-  const dsn = client2?.getDsn();
-  if (!dsn?.host || !dsn.projectId) {
-    return void 0;
-  }
-  const orgSlug = getSentryOrgSlug();
-  if (!orgSlug) {
-    return void 0;
-  }
-  const encodedId = encodeURIComponent(conversationId);
-  const params = new URLSearchParams();
-  params.set("project", dsn.projectId);
-  const path11 = `explore/conversations/${encodedId}/?${params.toString()}`;
-  if (isSentrySaasDsnHost(dsn.host)) {
-    return `https://${orgSlug}.sentry.io/${path11}`;
-  }
-  return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path11}`;
-}
 function formatSlackTokenCount(value) {
   if (value >= 1e6) {
     const millions = value / 1e6;
@@ -13827,7 +13716,7 @@ function buildSlackReplyFooter(args) {
       label: "ID",
       value: conversationId
     };
-    const conversationUrl = getSentryConversationUrl(conversationId);
+    const conversationUrl = buildSentryConversationUrl(conversationId);
     if (conversationUrl) {
       idItem.url = conversationUrl;
     }
@@ -14130,17 +14019,17 @@ function canScheduleTurnTimeoutResume(nextSliceId) {
   return typeof nextSliceId === "number" && nextSliceId > 1 && nextSliceId <= MAX_TURN_TIMEOUT_RESUME_SLICE_ID;
 }
 async function getAwaitingTurnContinuationRequest(args) {
-  const checkpoint = await getAgentTurnSessionCheckpoint(
+  const sessionRecord = await getAgentTurnSessionRecord(
     args.conversationId,
     args.sessionId
   );
-  if (!checkpoint || checkpoint.state !== "awaiting_resume" || checkpoint.resumeReason !== "timeout" || !canScheduleTurnTimeoutResume(checkpoint.sliceId)) {
+  if (!sessionRecord || sessionRecord.state !== "awaiting_resume" || sessionRecord.resumeReason !== "timeout" || !canScheduleTurnTimeoutResume(sessionRecord.sliceId)) {
     return void 0;
   }
   return {
     conversationId: args.conversationId,
     sessionId: args.sessionId,
-    expectedCheckpointVersion: checkpoint.checkpointVersion
+    expectedVersion: sessionRecord.version
   };
 }
 function getTurnTimeoutResumeSecret() {
@@ -14166,13 +14055,14 @@ function parseTurnTimeoutResumeRequest(value) {
     return void 0;
   }
   const record = value;
-  if (typeof record.conversationId !== "string" || typeof record.sessionId !== "string" || typeof record.expectedCheckpointVersion !== "number") {
+  const expectedVersion = typeof record.expectedVersion === "number" ? record.expectedVersion : record.expectedCheckpointVersion;
+  if (typeof record.conversationId !== "string" || typeof record.sessionId !== "string" || typeof expectedVersion !== "number") {
     return void 0;
   }
   return {
     conversationId: record.conversationId,
     sessionId: record.sessionId,
-    expectedCheckpointVersion: record.expectedCheckpointVersion
+    expectedVersion
   };
 }
 async function scheduleTurnTimeoutResume(request) {
@@ -14328,7 +14218,6 @@ async function verifyDispatchCallbackRequest(request) {
 
 // src/chat/agent-dispatch/store.ts
 import { createHash as createHash2 } from "crypto";
-import { THREAD_STATE_TTL_MS as THREAD_STATE_TTL_MS4 } from "chat";
 var DISPATCH_PREFIX = "junior:agent_dispatch";
 var DISPATCH_LOCK_TTL_MS = 10 * 60 * 1e3;
 var DISPATCH_INDEX_LOCK_TTL_MS = 1e4;
@@ -14359,9 +14248,12 @@ function buildDispatchId(plugin, idempotencyKey) {
   const digest = createHash2("sha256").update(plugin).update("\0").update(idempotencyKey).digest("hex").slice(0, 32);
   return `dispatch_${digest}`;
 }
-function getDispatchConversationId(destination) {
+function getDispatchDestinationLockId(destination) {
   return `slack:${destination.teamId}:${destination.channelId}`;
 }
+function getDispatchConversationId(dispatch) {
+  return `agent-dispatch:${dispatch.id}`;
+}
 function getDispatchTurnId(dispatchId) {
   return `dispatch:${dispatchId}`;
 }
@@ -14419,7 +14311,7 @@ async function syncIncompleteDispatchIndex(state, record) {
     await state.set(
       incompleteDispatchIndexKey(),
       next.slice(-DISPATCH_INDEX_MAX_LENGTH),
-      THREAD_STATE_TTL_MS4
+      JUNIOR_THREAD_STATE_TTL_MS
     );
   });
 }
@@ -14427,7 +14319,7 @@ async function putRecord(state, record) {
   await state.set(
     getDispatchStorageKey(record.id),
     record,
-    THREAD_STATE_TTL_MS4
+    JUNIOR_THREAD_STATE_TTL_MS
   );
   await syncIncompleteDispatchIndex(state, record);
 }
@@ -14541,7 +14433,6 @@ async function markDispatch(args) {
       ...current,
       status: args.status,
       ...args.errorMessage ? { errorMessage: args.errorMessage } : {},
-      ...typeof args.resumeCheckpointVersion === "number" ? { resumeCheckpointVersion: args.resumeCheckpointVersion } : {},
       ...args.resultMessageTs ? { resultMessageTs: args.resultMessageTs } : {}
     });
   });
@@ -14578,14 +14469,15 @@ async function runAgentDispatchSlice(callback, deps = {}) {
     return;
   }
   let dispatch = claimedDispatch;
-  const conversationId = getDispatchConversationId(dispatch.destination);
+  const conversationId = getDispatchConversationId(dispatch);
+  const destinationLockId = getDispatchDestinationLockId(dispatch.destination);
   const stateAdapter = getStateAdapter();
   await stateAdapter.connect();
-  const conversationLock = await stateAdapter.acquireLock(
-    conversationId,
+  const destinationLock = await stateAdapter.acquireLock(
+    destinationLockId,
     DISPATCH_SLICE_LEASE_MS
   );
-  if (!conversationLock) {
+  if (!destinationLock) {
     await markDispatch({
       dispatch,
       status: "pending",
@@ -14774,12 +14666,11 @@ async function runAgentDispatchSlice(callback, deps = {}) {
       return;
     }
     if (isRetryableTurnError(error, "turn_timeout_resume")) {
-      const checkpointVersion = error.metadata?.checkpointVersion;
+      const version = error.metadata?.version;
       const nextSliceId = error.metadata?.sliceId;
-      if (typeof checkpointVersion === "number" && canScheduleTurnTimeoutResume(nextSliceId)) {
+      if (typeof version === "number" && canScheduleTurnTimeoutResume(nextSliceId)) {
         const awaiting = await markDispatch({
           dispatch,
-          resumeCheckpointVersion: checkpointVersion,
           status: "awaiting_resume"
         });
         await scheduleCallback({
@@ -14811,7 +14702,7 @@ async function runAgentDispatchSlice(callback, deps = {}) {
       errorMessage: error instanceof Error ? error.message : String(error)
     });
   } finally {
-    await stateAdapter.releaseLock(conversationLock);
+    await stateAdapter.releaseLock(destinationLock);
   }
 }
 
@@ -15125,7 +15016,7 @@ function verifyHeartbeatRequest(request) {
   const expected = Buffer.from(secret);
   return actual.length === expected.length && timingSafeEqual4(actual, expected);
 }
-async function GET4(request, waitUntil) {
+async function GET2(request, waitUntil) {
   if (!verifyHeartbeatRequest(request)) {
     return new Response("Unauthorized", { status: 401 });
   }
@@ -15144,6 +15035,9 @@ async function GET4(request, waitUntil) {
   return new Response("Accepted", { status: 202 });
 }
 
+// src/handlers/mcp-oauth-callback.ts
+import { THREAD_STATE_TTL_MS as THREAD_STATE_TTL_MS4 } from "chat";
+
 // src/chat/runtime/delivered-turn-state.ts
 function buildDeliveredTurnStatePatch(args) {
   const conversation = structuredClone(args.conversation);
@@ -15490,7 +15384,7 @@ function createSlackAdapterStatusSender(args) {
   };
 }
 function createSlackWebApiStatusSender(args) {
-  const getClient3 = args.getSlackClient ?? getSlackClient;
+  const getClient2 = args.getSlackClient ?? getSlackClient;
   return async (text, loadingMessages) => {
     const channelId = args.channelId;
     const threadTs = args.threadTs;
@@ -15503,7 +15397,7 @@ function createSlackWebApiStatusSender(args) {
     }
     const nextLoadingMessages = text ? loadingMessages ?? [text] : void 0;
     try {
-      await getClient3().assistant.threads.setStatus({
+      await getClient2().assistant.threads.setStatus({
         channel_id: normalizedChannelId,
         thread_ts: threadTs,
         status: text ? SLACK_ASSISTANT_ACTIVE_STATUS : "",
@@ -15649,52 +15543,6 @@ function getWorkspaceTeamId() {
   return workspaceTeamIdStorage.getStore();
 }
 
-// src/chat/slack/context.ts
-function toTrimmedSlackString(value) {
-  const normalized = toOptionalString(value);
-  return normalized?.trim() || void 0;
-}
-function parseSlackThreadId(threadId) {
-  const normalizedThreadId = toTrimmedSlackString(threadId);
-  if (!normalizedThreadId) {
-    return void 0;
-  }
-  const parts = normalizedThreadId.split(":");
-  if (parts.length !== 3 || parts[0] !== "slack") {
-    return void 0;
-  }
-  const channelId = toTrimmedSlackString(parts[1]);
-  const threadTs = toTrimmedSlackString(parts[2]);
-  if (!channelId || !threadTs) {
-    return void 0;
-  }
-  return { channelId, threadTs };
-}
-function resolveSlackChannelIdFromThreadId(threadId) {
-  return parseSlackThreadId(threadId)?.channelId;
-}
-function resolveSlackChannelIdFromMessage(message) {
-  const messageChannelId = toTrimmedSlackString(
-    message.channelId
-  );
-  if (messageChannelId) {
-    return messageChannelId;
-  }
-  const raw = message.raw;
-  if (raw && typeof raw === "object") {
-    const rawChannel = toTrimmedSlackString(
-      raw.channel
-    );
-    if (rawChannel) {
-      return rawChannel;
-    }
-  }
-  const threadId = toTrimmedSlackString(
-    message.threadId
-  );
-  return resolveSlackChannelIdFromThreadId(threadId);
-}
-
 // src/chat/runtime/thread-context.ts
 function toSlackTeamId(value) {
   const candidate = toOptionalString(value);
@@ -16070,7 +15918,7 @@ async function resumeSlackTurn(args) {
     status.start();
     const generateReply = runArgs.generateReply ?? generateAssistantReply;
     const replyContext = createResumeReplyContext(runArgs, status);
-    const priorCheckpoint = replyContext.correlation?.conversationId && replyContext.correlation?.turnId ? await getAgentTurnSessionCheckpoint(
+    const priorSessionRecord = replyContext.correlation?.conversationId && replyContext.correlation?.turnId ? await getAgentTurnSessionRecord(
       replyContext.correlation.conversationId,
       replyContext.correlation.turnId
     ) : void 0;
@@ -16097,10 +15945,10 @@ async function resumeSlackTurn(args) {
     await status.stop();
     const footer = buildSlackReplyFooter({
       conversationId: runArgs.replyContext?.correlation?.conversationId ?? lockKey,
-      durationMs: typeof priorCheckpoint?.cumulativeDurationMs === "number" || typeof reply.diagnostics.durationMs === "number" ? (priorCheckpoint?.cumulativeDurationMs ?? 0) + (reply.diagnostics.durationMs ?? 0) : void 0,
+      durationMs: typeof priorSessionRecord?.cumulativeDurationMs === "number" || typeof reply.diagnostics.durationMs === "number" ? (priorSessionRecord?.cumulativeDurationMs ?? 0) + (reply.diagnostics.durationMs ?? 0) : void 0,
       thinkingLevel: reply.diagnostics.thinkingLevel,
       usage: addAgentTurnUsage(
-        priorCheckpoint?.cumulativeUsage,
+        priorSessionRecord?.cumulativeUsage,
         reply.diagnostics.usage
       ) ?? reply.diagnostics.usage
     });
@@ -16291,6 +16139,9 @@ var CALLBACK_PAGES = {
     status: 500
   }
 };
+function mcpAuthorizationId(args) {
+  return `${args.sessionId}:mcp:${args.provider}`;
+}
 function htmlResponse(kind) {
   const page = CALLBACK_PAGES[kind];
   return htmlCallbackResponse(page.title, page.message, page.status);
@@ -16312,27 +16163,28 @@ async function persistCompletedReplyState(channelId, threadTs, sessionId, reply)
     ...statePatch
   });
 }
-async function failCheckpointBestEffort(args) {
+async function failSessionRecordBestEffort(args) {
   try {
-    await failAgentTurnSessionCheckpoint({
+    await failAgentTurnSessionRecord({
       conversationId: args.conversationId,
       sessionId: args.sessionId,
-      errorMessage: args.errorMessage
+      errorMessage: args.errorMessage,
+      expectedVersion: args.expectedVersion
     });
   } catch (error) {
     logException(
       error,
-      "mcp_oauth_callback_checkpoint_fail_persist_failed",
+      "mcp_oauth_callback_session_record_fail_persist_failed",
       {},
       {
         "app.ai.conversation_id": args.conversationId,
         "app.ai.session_id": args.sessionId
       },
-      "Failed to mark MCP OAuth-resumed turn checkpoint failed"
+      "Failed to mark MCP OAuth-resumed turn session record failed"
     );
   }
 }
-async function persistFailedReplyState(channelId, threadTs, sessionId) {
+async function persistFailedReplyState(channelId, threadTs, sessionId, expectedVersion) {
   const threadId = `slack:${channelId}:${threadTs}`;
   const currentState = await getPersistedThreadState(threadId);
   const conversation = coerceThreadConversationState(currentState);
@@ -16345,10 +16197,11 @@ async function persistFailedReplyState(channelId, threadTs, sessionId) {
     markConversationMessage,
     updateConversationStats
   });
-  await failCheckpointBestEffort({
+  await failSessionRecordBestEffort({
     conversationId: threadId,
     sessionId,
-    errorMessage: "OAuth-resumed MCP turn failed"
+    errorMessage: "OAuth-resumed MCP turn failed",
+    expectedVersion
   });
   await persistThreadStateById(threadId, {
     conversation
@@ -16374,10 +16227,10 @@ async function resumeAuthorizedMcpTurn(args) {
     if (!isPendingAuthLatestRequest(conversation, pendingAuth)) {
       clearPendingAuth(conversation, pendingAuth.sessionId);
       await persistThreadStateById(threadId, { conversation });
-      await supersedeAgentTurnSessionCheckpoint({
+      await abandonAgentTurnSessionRecord({
         conversationId: authSession.conversationId,
         sessionId: pendingAuth.sessionId,
-        errorMessage: "Auth completed after a newer thread message superseded this blocked request."
+        errorMessage: "Auth completed after a newer thread message abandoned this blocked request."
       });
       return;
     }
@@ -16414,10 +16267,10 @@ async function resumeAuthorizedMcpTurn(args) {
           await persistThreadStateById(threadId, {
             conversation: lockedConversation
           });
-          await supersedeAgentTurnSessionCheckpoint({
+          await abandonAgentTurnSessionRecord({
             conversationId: authSession.conversationId,
             sessionId: lockedPendingAuth.sessionId,
-            errorMessage: "Auth completed after a newer thread message superseded this blocked request."
+            errorMessage: "Auth completed after a newer thread message abandoned this blocked request."
           });
           return false;
         }
@@ -16431,6 +16284,13 @@ async function resumeAuthorizedMcpTurn(args) {
       if (!lockedUserMessage) {
         return false;
       }
+      const lockedSessionRecord = await getAgentTurnSessionRecord(
+        authSession.conversationId,
+        lockedSessionId
+      );
+      if (!lockedSessionRecord || lockedSessionRecord.state !== "awaiting_resume" || lockedSessionRecord.resumeReason !== "auth") {
+        return false;
+      }
       const lockedConversationContext = buildConversationContext(
         lockedConversation,
         {
@@ -16440,6 +16300,17 @@ async function resumeAuthorizedMcpTurn(args) {
       const lockedChannelConfiguration = getChannelConfigurationServiceById(
         authSession.channelId
       );
+      await recordAuthorizationCompleted({
+        conversationId: authSession.conversationId,
+        kind: "mcp",
+        provider,
+        requesterId: authSession.userId,
+        authorizationId: mcpAuthorizationId({
+          provider,
+          sessionId: lockedSessionId
+        }),
+        ttlMs: THREAD_STATE_TTL_MS4
+      });
       return {
         messageText: lockedUserMessage.text,
         messageTs: getTurnUserSlackMessageTs(lockedUserMessage),
@@ -16485,8 +16356,9 @@ async function resumeAuthorizedMcpTurn(args) {
           );
         },
         onPostDeliveryCommitFailure: async () => {
-          await failAgentTurnSessionCheckpoint({
+          await failAgentTurnSessionRecord({
             conversationId: authSession.conversationId,
+            expectedVersion: lockedSessionRecord.version,
             sessionId: lockedSessionId,
             errorMessage: "OAuth-resumed MCP reply was delivered but completion state did not persist"
           });
@@ -16496,7 +16368,8 @@ async function resumeAuthorizedMcpTurn(args) {
             await persistFailedReplyState(
               authSession.channelId,
               authSession.threadTs,
-              lockedSessionId
+              lockedSessionId,
+              lockedSessionRecord.version
             );
           } catch (persistError) {
             logException(
@@ -16527,11 +16400,11 @@ async function resumeAuthorizedMcpTurn(args) {
           if (!isRetryableTurnError(error, "turn_timeout_resume")) {
             throw error;
           }
-          const checkpointVersion = error.metadata?.checkpointVersion;
+          const version = error.metadata?.version;
           const nextSliceId = error.metadata?.sliceId;
-          if (typeof checkpointVersion !== "number") {
+          if (typeof version !== "number") {
             throw new Error(
-              "Timed-out MCP resume did not include a checkpoint version"
+              "Timed-out MCP resume did not include a turn-session version"
             );
           }
           if (!canScheduleTurnTimeoutResume(nextSliceId)) {
@@ -16551,14 +16424,14 @@ async function resumeAuthorizedMcpTurn(args) {
           await scheduleTurnTimeoutResume({
             conversationId: authSession.conversationId,
             sessionId: lockedSessionId,
-            expectedCheckpointVersion: checkpointVersion
+            expectedVersion: version
           });
         }
       };
     }
   });
 }
-async function GET5(request, provider, waitUntil) {
+async function GET3(request, provider, waitUntil) {
   const url = new URL(request.url);
   const state = url.searchParams.get("state")?.trim();
   const code = url.searchParams.get("code")?.trim();
@@ -16604,9 +16477,12 @@ async function GET5(request, provider, waitUntil) {
   }
 }
 
+// src/handlers/oauth-callback.ts
+import { THREAD_STATE_TTL_MS as THREAD_STATE_TTL_MS5 } from "chat";
+
 // src/chat/slack/app-home.ts
 import fs5 from "fs";
-import path10 from "path";
+import path9 from "path";
 var DEFAULT_DESCRIPTION_TEXT = "I help your team investigate, summarize, and act on work in Slack.";
 var MAX_HOME_SKILLS = 6;
 var MAX_SECTION_TEXT_CHARS = 3e3;
@@ -16618,7 +16494,7 @@ function clampSectionText(text) {
   return `${text.slice(0, MAX_SECTION_TEXT_CHARS - 1)}\u2026`;
 }
 function loadDescriptionText() {
-  const descriptionPath = path10.join(homeDir(), "DESCRIPTION.md");
+  const descriptionPath = path9.join(homeDir(), "DESCRIPTION.md");
   try {
     const raw = fs5.readFileSync(descriptionPath, "utf8").trim();
     if (raw.length > 0) {
@@ -16769,23 +16645,27 @@ async function persistCompletedOAuthReplyState(args) {
     ...statePatch
   });
 }
-async function failCheckpointBestEffort2(args) {
+function pluginAuthorizationId(args) {
+  return `${args.sessionId}:plugin:${args.provider}`;
+}
+async function failSessionRecordBestEffort2(args) {
   try {
-    await failAgentTurnSessionCheckpoint({
+    await failAgentTurnSessionRecord({
       conversationId: args.conversationId,
+      expectedVersion: args.expectedVersion,
       sessionId: args.sessionId,
       errorMessage: args.errorMessage
     });
   } catch (error) {
     logException(
       error,
-      "oauth_callback_checkpoint_fail_persist_failed",
+      "oauth_callback_session_record_fail_persist_failed",
       {},
       {
         "app.ai.conversation_id": args.conversationId,
         "app.ai.session_id": args.sessionId
       },
-      "Failed to mark OAuth-resumed turn checkpoint failed"
+      "Failed to mark OAuth-resumed turn session record failed"
     );
   }
 }
@@ -16801,8 +16681,9 @@ async function persistFailedOAuthReplyState(args) {
     markConversationMessage,
     updateConversationStats
   });
-  await failCheckpointBestEffort2({
+  await failSessionRecordBestEffort2({
     conversationId: args.conversationId,
+    expectedVersion: args.expectedVersion,
     sessionId: args.sessionId,
     errorMessage: "OAuth-resumed turn failed"
   });
@@ -16810,21 +16691,21 @@ async function persistFailedOAuthReplyState(args) {
     conversation
   });
 }
-async function resumeCheckpointedOAuthTurn(stored) {
+async function resumeOAuthSessionRecordTurn(stored) {
   if (!stored.resumeConversationId || !stored.resumeSessionId || !stored.channelId || !stored.threadTs) {
     return false;
   }
-  const checkpoint = await getAgentTurnSessionCheckpoint(
+  const sessionRecord = await getAgentTurnSessionRecord(
     stored.resumeConversationId,
     stored.resumeSessionId
   );
-  if (!checkpoint) {
+  if (!sessionRecord) {
     return false;
   }
-  if (checkpoint.state === "completed" || checkpoint.state === "failed" || checkpoint.state === "superseded") {
+  if (sessionRecord.state === "completed" || sessionRecord.state === "failed" || sessionRecord.state === "abandoned") {
     return true;
   }
-  if (checkpoint.state !== "awaiting_resume" || checkpoint.resumeReason !== "auth") {
+  if (sessionRecord.state !== "awaiting_resume" || sessionRecord.resumeReason !== "auth") {
     return true;
   }
   const currentState = await getPersistedThreadState(
@@ -16845,10 +16726,10 @@ async function resumeCheckpointedOAuthTurn(stored) {
       await persistThreadStateById(stored.resumeConversationId, {
         conversation
       });
-      await supersedeAgentTurnSessionCheckpoint({
+      await abandonAgentTurnSessionRecord({
         conversationId: stored.resumeConversationId,
         sessionId: pendingAuth.sessionId,
-        errorMessage: "Auth completed after a newer thread message superseded this blocked request."
+        errorMessage: "Auth completed after a newer thread message abandoned this blocked request."
       });
       return true;
     }
@@ -16871,11 +16752,11 @@ async function resumeCheckpointedOAuthTurn(stored) {
     lockKey: stored.resumeConversationId,
     initialText: "",
     beforeStart: async () => {
-      const lockedCheckpoint = await getAgentTurnSessionCheckpoint(
+      const lockedSessionRecord = await getAgentTurnSessionRecord(
         stored.resumeConversationId,
         stored.resumeSessionId
       );
-      if (!lockedCheckpoint || lockedCheckpoint.state !== "awaiting_resume" || lockedCheckpoint.resumeReason !== "auth") {
+      if (!lockedSessionRecord || lockedSessionRecord.state !== "awaiting_resume" || lockedSessionRecord.resumeReason !== "auth") {
         return false;
       }
       const lockedState = await getPersistedThreadState(
@@ -16899,10 +16780,10 @@ async function resumeCheckpointedOAuthTurn(stored) {
           await persistThreadStateById(stored.resumeConversationId, {
             conversation: lockedConversation
           });
-          await supersedeAgentTurnSessionCheckpoint({
+          await abandonAgentTurnSessionRecord({
             conversationId: stored.resumeConversationId,
             sessionId: lockedPendingAuth.sessionId,
-            errorMessage: "Auth completed after a newer thread message superseded this blocked request."
+            errorMessage: "Auth completed after a newer thread message abandoned this blocked request."
           });
           return false;
         }
@@ -16925,6 +16806,17 @@ async function resumeCheckpointedOAuthTurn(stored) {
       const lockedChannelConfiguration = getChannelConfigurationServiceById(
         stored.channelId
       );
+      await recordAuthorizationCompleted({
+        conversationId: stored.resumeConversationId,
+        kind: "plugin",
+        provider: stored.provider,
+        requesterId: stored.userId,
+        authorizationId: pluginAuthorizationId({
+          provider: stored.provider,
+          sessionId: lockedSessionId
+        }),
+        ttlMs: THREAD_STATE_TTL_MS5
+      });
       return {
         messageText: stored.pendingMessage ?? lockedUserMessage.text,
         messageTs: getTurnUserSlackMessageTs(lockedUserMessage),
@@ -16969,7 +16861,7 @@ async function resumeCheckpointedOAuthTurn(stored) {
               "app.ai.outcome": reply.diagnostics.outcome,
               "app.ai.tool_calls": reply.diagnostics.toolCalls.length
             },
-            "OAuth callback auto-resumed checkpoint finished replying"
+            "OAuth callback auto-resumed session record finished replying"
           );
           await persistCompletedOAuthReplyState({
             conversationId: stored.resumeConversationId,
@@ -16978,9 +16870,9 @@ async function resumeCheckpointedOAuthTurn(stored) {
           });
         },
         onPostDeliveryCommitFailure: async () => {
-          await failAgentTurnSessionCheckpoint({
+          await failAgentTurnSessionRecord({
             conversationId: stored.resumeConversationId,
-            expectedCheckpointVersion: lockedCheckpoint.checkpointVersion,
+            expectedVersion: lockedSessionRecord.version,
             sessionId: lockedSessionId,
             errorMessage: "OAuth-resumed reply was delivered but completion state did not persist"
           });
@@ -16988,6 +16880,7 @@ async function resumeCheckpointedOAuthTurn(stored) {
         onFailure: async () => {
           await persistFailedOAuthReplyState({
             conversationId: stored.resumeConversationId,
+            expectedVersion: lockedSessionRecord.version,
             sessionId: lockedSessionId
           });
         },
@@ -17001,11 +16894,11 @@ async function resumeCheckpointedOAuthTurn(stored) {
           if (!isRetryableTurnError(error, "turn_timeout_resume")) {
             throw error;
           }
-          const checkpointVersion = error.metadata?.checkpointVersion;
+          const version = error.metadata?.version;
           const nextSliceId = error.metadata?.sliceId;
-          if (typeof checkpointVersion !== "number") {
+          if (typeof version !== "number") {
             throw new Error(
-              "Timed-out OAuth resume did not include a checkpoint version"
+              "Timed-out OAuth resume did not include a turn-session version"
             );
           }
           if (!canScheduleTurnTimeoutResume(nextSliceId)) {
@@ -17016,7 +16909,7 @@ async function resumeCheckpointedOAuthTurn(stored) {
           await scheduleTurnTimeoutResume({
             conversationId: stored.resumeConversationId,
             sessionId: lockedSessionId,
-            expectedCheckpointVersion: checkpointVersion
+            expectedVersion: version
           });
         }
       };
@@ -17060,7 +16953,7 @@ async function resumePendingOAuthMessage(stored) {
     }
   });
 }
-async function GET6(request, provider, waitUntil) {
+async function GET4(request, provider, waitUntil) {
   const providerConfig = getPluginOAuthConfig(provider);
   if (!providerConfig) {
     return htmlErrorResponse(
@@ -17199,7 +17092,7 @@ async function GET6(request, provider, waitUntil) {
   if (stored.pendingMessage && stored.channelId && stored.threadTs) {
     waitUntil(async () => {
       try {
-        const resumed = await resumeCheckpointedOAuthTurn(stored);
+        const resumed = await resumeOAuthSessionRecordTurn(stored);
         if (!resumed) {
           await resumePendingOAuthMessage(stored);
         }
@@ -17431,12 +17324,12 @@ function normalizePort(value) {
 function sandboxIdFromPayload(payload) {
   return typeof payload.sandbox_id === "string" ? payload.sandbox_id : void 0;
 }
-function normalizedForwardedPath(path11) {
-  if (!path11.startsWith("/") || path11.startsWith("//") || path11.includes("#") || /[\r\n]/.test(path11)) {
+function normalizedForwardedPath(path10) {
+  if (!path10.startsWith("/") || path10.startsWith("//") || path10.includes("#") || /[\r\n]/.test(path10)) {
     return { ok: false, error: "Invalid forwarded path" };
   }
   try {
-    const url = new URL(path11, "https://sandbox-forwarded.local");
+    const url = new URL(path10, "https://sandbox-forwarded.local");
     return { ok: true, path: `${url.pathname}${url.search}` };
   } catch {
     return { ok: false, error: "Invalid forwarded path" };
@@ -17471,13 +17364,13 @@ function buildUpstreamUrl(request) {
   if (forwardedPort && !port) {
     return { ok: false, error: "Invalid forwarded port" };
   }
-  const path11 = upstreamPath(request);
-  if (!path11.ok) {
-    return { ok: false, error: path11.error };
+  const path10 = upstreamPath(request);
+  if (!path10.ok) {
+    return { ok: false, error: path10.error };
   }
   try {
     const url = new URL(
-      `${scheme}://${host}${port ? `:${port}` : ""}${path11.path}`
+      `${scheme}://${host}${port ? `:${port}` : ""}${path10.path}`
     );
     return { ok: true, url };
   } catch {
@@ -17794,63 +17687,65 @@ function sleep4(ms) {
 }
 async function persistCompletedReplyState2(args) {
   const currentState = await getPersistedThreadState(
-    args.checkpoint.conversationId
+    args.sessionRecord.conversationId
   );
   const conversation = coerceThreadConversationState(currentState);
   const artifacts = coerceThreadArtifactsState(currentState);
   const userMessage2 = getTurnUserMessage(
     conversation,
-    args.checkpoint.sessionId
+    args.sessionRecord.sessionId
   );
   const statePatch = buildDeliveredTurnStatePatch({
     artifacts,
     conversation,
     reply: args.reply,
-    sessionId: args.checkpoint.sessionId,
+    sessionId: args.sessionRecord.sessionId,
     userMessageId: userMessage2?.id
   });
-  await persistThreadStateById(args.checkpoint.conversationId, {
+  await persistThreadStateById(args.sessionRecord.conversationId, {
     ...statePatch
   });
 }
-async function failCheckpointBestEffort3(args) {
+async function failSessionRecordBestEffort3(args) {
   try {
-    await failAgentTurnSessionCheckpoint({
-      conversationId: args.checkpoint.conversationId,
-      expectedCheckpointVersion: args.checkpoint.checkpointVersion,
-      sessionId: args.checkpoint.sessionId,
+    await failAgentTurnSessionRecord({
+      conversationId: args.sessionRecord.conversationId,
+      expectedVersion: args.sessionRecord.version,
+      sessionId: args.sessionRecord.sessionId,
       errorMessage: args.errorMessage
     });
   } catch (error) {
     logException(
       error,
-      "timeout_resume_checkpoint_fail_persist_failed",
+      "timeout_resume_session_record_fail_persist_failed",
       {},
       {
-        "app.ai.conversation_id": args.checkpoint.conversationId,
-        "app.ai.session_id": args.checkpoint.sessionId
+        "app.ai.conversation_id": args.sessionRecord.conversationId,
+        "app.ai.session_id": args.sessionRecord.sessionId
       },
-      "Failed to mark timed-out turn checkpoint failed"
+      "Failed to mark timed-out turn session record failed"
     );
   }
 }
-async function persistFailedReplyState2(checkpoint) {
-  const currentState = await getPersistedThreadState(checkpoint.conversationId);
+async function persistFailedReplyState2(sessionRecord) {
+  const currentState = await getPersistedThreadState(
+    sessionRecord.conversationId
+  );
   const conversation = coerceThreadConversationState(currentState);
-  clearPendingAuth(conversation, checkpoint.sessionId);
+  clearPendingAuth(conversation, sessionRecord.sessionId);
   markTurnFailed({
     conversation,
     nowMs: Date.now(),
-    sessionId: checkpoint.sessionId,
-    userMessageId: getTurnUserMessage(conversation, checkpoint.sessionId)?.id,
+    sessionId: sessionRecord.sessionId,
+    userMessageId: getTurnUserMessage(conversation, sessionRecord.sessionId)?.id,
     markConversationMessage,
     updateConversationStats
   });
-  await failCheckpointBestEffort3({
-    checkpoint,
+  await failSessionRecordBestEffort3({
+    sessionRecord,
     errorMessage: "Timed-out turn failed while resuming"
   });
-  await persistThreadStateById(checkpoint.conversationId, {
+  await persistThreadStateById(sessionRecord.conversationId, {
     conversation
   });
 }
@@ -17867,11 +17762,11 @@ async function resumeTimedOutTurn(payload) {
     threadTs: thread.threadTs,
     lockKey: payload.conversationId,
     beforeStart: async () => {
-      const checkpoint = await getAgentTurnSessionCheckpoint(
+      const sessionRecord = await getAgentTurnSessionRecord(
         payload.conversationId,
         payload.sessionId
       );
-      if (!checkpoint || checkpoint.state !== "awaiting_resume" || checkpoint.resumeReason !== "timeout" || checkpoint.checkpointVersion !== payload.expectedCheckpointVersion) {
+      if (!sessionRecord || sessionRecord.state !== "awaiting_resume" || sessionRecord.resumeReason !== "timeout" || sessionRecord.version !== payload.expectedVersion) {
         return false;
       }
       const currentState = await getPersistedThreadState(
@@ -17931,16 +17826,16 @@ async function resumeTimedOutTurn(payload) {
           ...getTurnUserReplyAttachmentContext(userMessage2)
         },
         onSuccess: async (reply) => {
-          await persistCompletedReplyState2({ checkpoint, reply });
+          await persistCompletedReplyState2({ sessionRecord, reply });
         },
         onFailure: async () => {
-          await persistFailedReplyState2(checkpoint);
+          await persistFailedReplyState2(sessionRecord);
         },
         onPostDeliveryCommitFailure: async () => {
-          await failAgentTurnSessionCheckpoint({
-            conversationId: checkpoint.conversationId,
-            expectedCheckpointVersion: checkpoint.checkpointVersion,
-            sessionId: checkpoint.sessionId,
+          await failAgentTurnSessionRecord({
+            conversationId: sessionRecord.conversationId,
+            expectedVersion: sessionRecord.version,
+            sessionId: sessionRecord.sessionId,
             errorMessage: "Timed-out turn reply was delivered but completion state did not persist"
           });
         },
@@ -17963,11 +17858,11 @@ async function resumeTimedOutTurn(payload) {
           if (!isRetryableTurnError(error, "turn_timeout_resume")) {
             throw error;
           }
-          const checkpointVersion = error.metadata?.checkpointVersion;
+          const version = error.metadata?.version;
           const nextSliceId = error.metadata?.sliceId;
-          if (typeof checkpointVersion !== "number") {
+          if (typeof version !== "number") {
             throw new Error(
-              "Timed-out resume turn did not include a checkpoint version"
+              "Timed-out resume turn did not include a turn-session version"
             );
           }
           if (!canScheduleTurnTimeoutResume(nextSliceId)) {
@@ -17988,7 +17883,7 @@ async function resumeTimedOutTurn(payload) {
           await scheduleTurnTimeoutResume({
             conversationId: payload.conversationId,
             sessionId: payload.sessionId,
-            expectedCheckpointVersion: checkpointVersion
+            expectedVersion: version
           });
         }
       };
@@ -18383,6 +18278,26 @@ async function decideSubscribedThreadReply(args) {
   }
 }
 
+// src/chat/runtime/turn-input.ts
+function combineTextParts(queuedTexts, latestText) {
+  const parts = [...queuedTexts, latestText].filter(
+    (part) => part.trim().length > 0
+  );
+  return parts.length > 0 ? parts.join("\n\n") : latestText;
+}
+function combineTurnText(queuedMessages, latestText) {
+  return {
+    rawText: combineTextParts(
+      queuedMessages.map((message) => message.rawText),
+      latestText.rawText
+    ),
+    userText: combineTextParts(
+      queuedMessages.map((message) => message.userText),
+      latestText.userText
+    )
+  };
+}
+
 // src/chat/runtime/slack-runtime.ts
 var THREAD_OPTOUT_ACK = "Understood. I'll stay out of this thread unless someone @mentions me again.";
 async function maybeHandleThreadOptOutDecision(args) {
@@ -18394,6 +18309,19 @@ async function maybeHandleThreadOptOutDecision(args) {
   await args.thread.post(THREAD_OPTOUT_ACK);
   return true;
 }
+function getQueuedMessages(context, options) {
+  return (context?.skipped ?? []).map((message) => {
+    const stripped = options.stripLeadingBotMention(message.text, {
+      stripLeadingSlackMentionToken: options.explicitMention || Boolean(message.isMention)
+    });
+    return {
+      explicitMention: options.explicitMention || Boolean(message.isMention),
+      message,
+      rawText: appendSlackLegacyAttachmentText(message.text, message.raw),
+      userText: appendSlackLegacyAttachmentText(stripped, message.raw)
+    };
+  });
+}
 function buildLogContext(deps, args) {
   return {
     conversationId: args.threadId ?? args.runId,
@@ -18463,7 +18391,7 @@ function createSlackTurnRuntime(deps) {
         message: args.message,
         decision: args.decision,
         completedAtMs,
-        userText: args.userText
+        text: args.text
       });
     }
   };
@@ -18493,9 +18421,14 @@ function createSlackTurnRuntime(deps) {
         );
         await deps.withSpan("chat.turn", "chat.turn", context, async () => {
           await thread.subscribe();
+          const queuedMessages = getQueuedMessages(hooks?.messageContext, {
+            explicitMention: true,
+            stripLeadingBotMention: deps.stripLeadingBotMention
+          });
           await deps.replyToThread(thread, message, {
             explicitMention: true,
             beforeFirstResponsePost: hooks?.beforeFirstResponsePost,
+            queuedMessages,
             onToolInvocation: toolInvocationHook
           });
         });
@@ -18558,28 +18491,33 @@ function createSlackTurnRuntime(deps) {
           const legacyAttachmentText = renderSlackLegacyAttachmentText(
             message.raw
           );
-          const rawUserText = appendSlackLegacyAttachmentText(
-            message.text,
-            message.raw
-          );
           const strippedUserText = deps.stripLeadingBotMention(message.text, {
             stripLeadingSlackMentionToken: Boolean(message.isMention)
           });
-          const userText = appendSlackLegacyAttachmentText(
-            strippedUserText,
-            message.raw
-          );
+          const currentText = {
+            rawText: appendSlackLegacyAttachmentText(message.text, message.raw),
+            userText: appendSlackLegacyAttachmentText(
+              strippedUserText,
+              message.raw
+            )
+          };
           const threadContext = {
             threadId,
             requesterId: message.author.userId,
             channelId,
             runId
           };
+          const queuedMessages = getQueuedMessages(hooks?.messageContext, {
+            explicitMention: Boolean(message.isMention),
+            stripLeadingBotMention: deps.stripLeadingBotMention
+          });
+          const combinedText = combineTurnText(queuedMessages, currentText);
+          const turnIsExplicitMention = Boolean(message.isMention) || queuedMessages.some((queued) => queued.explicitMention);
           const preflightDecision = getSubscribedReplyPreflightDecision({
             botUserName: deps.assistantUserName,
-            rawText: rawUserText,
-            text: userText,
-            isExplicitMention: Boolean(message.isMention)
+            rawText: combinedText.rawText,
+            text: combinedText.userText,
+            isExplicitMention: turnIsExplicitMention
           });
           if (preflightDecision && !preflightDecision.shouldReply) {
             const reason = preflightDecision.reasonDetail ? `${preflightDecision.reason}:${preflightDecision.reasonDetail}` : preflightDecision.reason;
@@ -18588,27 +18526,30 @@ function createSlackTurnRuntime(deps) {
               message,
               decision: { shouldReply: false, reason },
               context: threadContext,
-              userText
+              text: combinedText
             });
             return;
           }
           const preparedState = await deps.prepareTurnState({
             thread,
             message,
-            userText,
+            text: currentText,
             explicitMention: Boolean(message.isMention),
-            context: threadContext
+            context: threadContext,
+            queuedMessages
           });
           await deps.persistPreparedState({
             thread,
             preparedState
           });
           const decision = await deps.decideSubscribedReply({
-            rawText: rawUserText,
-            text: userText,
+            rawText: combinedText.rawText,
+            text: combinedText.userText,
             conversationContext: deps.getPreparedConversationContext(preparedState),
-            hasAttachments: message.attachments.length > 0 || legacyAttachmentText !== "",
-            isExplicitMention: Boolean(message.isMention),
+            hasAttachments: message.attachments.length > 0 || queuedMessages.some(
+              (queued) => queued.message.attachments.length > 0
+            ) || legacyAttachmentText !== "",
+            isExplicitMention: turnIsExplicitMention,
             context: threadContext
           });
           if (await maybeHandleThreadOptOutDecision({
@@ -18622,7 +18563,7 @@ function createSlackTurnRuntime(deps) {
               decision,
               context: threadContext,
               preparedState,
-              userText
+              text: combinedText
             });
             return;
           }
@@ -18633,7 +18574,7 @@ function createSlackTurnRuntime(deps) {
               decision,
               context: threadContext,
               preparedState,
-              userText
+              text: combinedText
             });
             return;
           }
@@ -18651,6 +18592,7 @@ function createSlackTurnRuntime(deps) {
             explicitMention: Boolean(message.isMention),
             preparedState,
             beforeFirstResponsePost: hooks?.beforeFirstResponsePost,
+            queuedMessages,
             onToolInvocation: toolInvocationHook
           });
         });
@@ -18748,6 +18690,7 @@ function createSlackTurnRuntime(deps) {
 }
 
 // src/chat/services/context-compaction.ts
+import { THREAD_STATE_TTL_MS as THREAD_STATE_TTL_MS6 } from "chat";
 import {
   estimateContextTokens,
   estimateTokens
@@ -18930,22 +18873,8 @@ function buildReplacementHistory(args) {
 ${args.summary}`)
   ];
 }
-function createCompactionSessionId(previousSessionId) {
-  return `compaction_${previousSessionId}`;
-}
-async function loadCompactionSource(args) {
-  const checkpoint = await getAgentTurnSessionCheckpoint(
-    args.conversationId,
-    args.previousSessionId
-  );
-  if (!checkpoint) {
-    return { reason: "missing_context" };
-  }
-  if (checkpoint.state !== "completed") {
-    return { reason: "not_completed" };
-  }
-  const messages = checkpoint.piMessages;
-  if (messages.length) {
+function loadCompactionSource(messages) {
+  if (messages.length > 0) {
     return {
       estimatedTokens: estimateHistoryTokens(messages),
       messages
@@ -18954,10 +18883,7 @@ async function loadCompactionSource(args) {
   return { reason: "missing_context" };
 }
 async function maybeCompactWithDeps(args, deps) {
-  const source = await loadCompactionSource({
-    conversationId: args.conversationId,
-    previousSessionId: args.previousSessionId
-  });
+  const source = loadCompactionSource(args.piMessages);
   if ("reason" in source) {
     return { compacted: false, reason: source.reason };
   }
@@ -19004,29 +18930,22 @@ async function writeCompactedThreadContext(args, sourceMessages, summary, contex
     messages: trimTrailingAssistantMessages(sourceMessages),
     summary
   });
-  const nextSessionId = createCompactionSessionId(args.previousSessionId);
-  await upsertAgentTurnSessionCheckpoint({
+  await commitMessages({
     conversationId: args.conversationId,
-    sessionId: nextSessionId,
-    sliceId: 1,
-    state: "completed",
-    piMessages: replacement
+    messages: replacement,
+    ttlMs: THREAD_STATE_TTL_MS6
   });
-  args.conversation.processing.lastSessionId = nextSessionId;
   updateConversationStats(args.conversation);
   setSpanAttributes({
     "app.compaction.input_messages": sourceMessages.length,
     "app.compaction.retained_messages": replacement.length - 1,
     "app.compaction.summary_chars": summary.length,
-    "app.compaction.previous_session_id": args.previousSessionId,
-    "app.compaction.next_session_id": nextSessionId,
     ...context.triggerTokens !== void 0 ? { "app.compaction.trigger_tokens": context.triggerTokens } : {},
     "app.context_tokens_estimated": context.estimatedTokens
   });
   return {
     compacted: true,
-    piMessages: replacement,
-    sessionId: nextSessionId
+    piMessages: replacement
   };
 }
 function createContextCompactor(deps) {
@@ -19736,7 +19655,7 @@ function maybeUpdateAssistantTitle(args) {
         assistantThreadContext.threadTs,
         title
       );
-      return titleSourceMessage.id;
+      return { sourceMessageId: titleSourceMessage.id, title };
     } catch (error) {
       const slackErrorCode = getSlackApiErrorCode(error);
       const assistantTitleErrorAttributes = {
@@ -19760,7 +19679,7 @@ function maybeUpdateAssistantTitle(args) {
           assistantTitleErrorAttributes,
           "Skipping thread title update due to Slack permission error"
         );
-        return titleSourceMessage.id;
+        return { sourceMessageId: titleSourceMessage.id };
       }
       logWarn(
         "thread_title_generation_failed",
@@ -19814,6 +19733,27 @@ function collectCanvasUrls(artifacts) {
     ].filter((url) => typeof url === "string" && url !== "")
   );
 }
+function turnRequester(args) {
+  const requester = {
+    ...args.email ? { email: args.email } : {},
+    ...args.fullName ? { fullName: args.fullName } : {},
+    ...args.userId ? { slackUserId: args.userId } : {},
+    ...args.userName ? { slackUserName: args.userName } : {}
+  };
+  return Object.keys(requester).length > 0 ? requester : void 0;
+}
+async function resolveChannelName(thread) {
+  const existingName = thread.channel.name?.trim();
+  if (existingName) {
+    return existingName;
+  }
+  try {
+    const metadata = await thread.channel.fetchMetadata();
+    return metadata.name?.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
 function getCurrentTurnCanvasUrl(args) {
   const previousUrls = collectCanvasUrls(args.before);
   const latestUrls = collectCanvasUrls(args.after);
@@ -19827,35 +19767,37 @@ function getCurrentTurnCanvasUrl(args) {
 function buildCanvasRecoveryReply(canvasUrl) {
   return `I created the canvas, but the turn was interrupted before I could finish the thread reply: ${canvasUrl}`;
 }
+function collectTurnAttachments(message, queuedMessages) {
+  return [
+    ...(queuedMessages ?? []).flatMap((queued) => queued.message.attachments),
+    ...message.attachments
+  ];
+}
 async function loadPiMessagesForTurn(args) {
   const fallback = args.fallback.length > 0 ? [...args.fallback] : void 0;
   if (!args.conversationId) {
     return { piMessages: fallback };
   }
   if (args.activeTurnId) {
-    const checkpoint2 = await getAgentTurnSessionCheckpoint(
+    const sessionRecord = await getAgentTurnSessionRecord(
       args.conversationId,
       args.activeTurnId
     );
-    if (checkpoint2?.piMessages.length) {
+    if (sessionRecord?.piMessages.length) {
       return {
         piMessages: stripRuntimeTurnContext(
-          trimTrailingAssistantMessages(checkpoint2.piMessages)
+          trimTrailingAssistantMessages(sessionRecord.piMessages)
         )
       };
     }
   }
-  if (!args.lastSessionId) {
-    return { piMessages: fallback };
-  }
-  const checkpoint = await getAgentTurnSessionCheckpoint(
-    args.conversationId,
-    args.lastSessionId
-  );
-  if (checkpoint?.state === "completed" && checkpoint.piMessages.length > 0) {
+  const projection = await loadProjection({
+    conversationId: args.conversationId
+  });
+  if (projection.length > 0) {
     return {
-      compactionSessionId: args.lastSessionId,
-      piMessages: stripRuntimeTurnContext(checkpoint.piMessages)
+      canCompact: true,
+      piMessages: projection
     };
   }
   return { piMessages: fallback };
@@ -19867,6 +19809,7 @@ function createReplyToThread(deps) {
     }
     const threadId = getThreadId(thread, message);
     const channelId = getChannelId(thread, message);
+    const channelName = channelId ? await resolveChannelName(thread) : void 0;
     const threadTs = getThreadTs(threadId);
     const assistantThreadContext = getAssistantThreadContext(message);
     const messageTs = getMessageTs(message);
@@ -19889,17 +19832,25 @@ function createReplyToThread(deps) {
         const strippedUserText = stripLeadingBotMention(message.text, {
           stripLeadingSlackMentionToken: options.explicitMention || Boolean(message.isMention)
         });
-        const userText = appendSlackLegacyAttachmentText(
-          strippedUserText,
-          message.raw
-        );
+        const currentText = {
+          rawText: appendSlackLegacyAttachmentText(message.text, message.raw),
+          userText: appendSlackLegacyAttachmentText(
+            strippedUserText,
+            message.raw
+          )
+        };
+        const effectiveUserText = combineTurnText(
+          options.queuedMessages ?? [],
+          currentText
+        ).userText;
         const preparedState = options.preparedState ?? await deps.prepareTurnState({
           thread,
           message,
-          userText,
+          text: currentText,
           explicitMention: Boolean(
             options.explicitMention || message.isMention
           ),
+          queuedMessages: options.queuedMessages,
           context: {
             threadId,
             requesterId: message.author.userId,
@@ -19909,6 +19860,15 @@ function createReplyToThread(deps) {
         });
         const slackMessageTs = getSlackMessageTs(message);
         const turnId = buildDeterministicTurnId(message.id);
+        const fallbackIdentity = await deps.services.lookupSlackUser(
+          message.author.userId
+        );
+        const requester = turnRequester({
+          email: fallbackIdentity?.email,
+          fullName: message.author.fullName ?? fallbackIdentity?.fullName,
+          userId: message.author.userId,
+          userName: message.author.userName ?? fallbackIdentity?.userName
+        });
         const turnTraceContext = {
           conversationId,
           slackThreadId: threadId,
@@ -19990,7 +19950,7 @@ function createReplyToThread(deps) {
                 "agent_turn_continuation_retry_schedule_failed",
                 turnTraceContext,
                 {
-                  "app.ai.resume_checkpoint_version": resumeRequest.expectedCheckpointVersion,
+                  "app.ai.resume_session_version": resumeRequest.expectedVersion,
                   "app.ai.resume_session_id": resumeRequest.sessionId,
                   ...messageTs ? { "messaging.message.id": messageTs } : {}
                 },
@@ -20013,11 +19973,10 @@ function createReplyToThread(deps) {
             return;
           }
         }
-        const lastSessionIdForHistory = preparedState.conversation.processing.lastSessionId;
         const configReply = await maybeApplyProviderDefaultConfigRequest({
           channelConfiguration: preparedState.channelConfiguration,
           requesterId: message.author.userId,
-          text: userText
+          text: effectiveUserText
         });
         if (configReply) {
           await beforeFirstResponsePost();
@@ -20053,6 +20012,28 @@ function createReplyToThread(deps) {
           nextTurnId: turnId,
           updateConversationStats
         });
+        if (conversationId) {
+          void recordAgentTurnSessionSummary({
+            channelName,
+            conversationId,
+            sessionId: turnId,
+            sliceId: 1,
+            startedAtMs: message.metadata.dateSent.getTime(),
+            state: "running",
+            requester,
+            traceId: getActiveTraceId()
+          }).catch((error) => {
+            logException(
+              error,
+              "agent_turn_summary_record_failed",
+              turnTraceContext,
+              {
+                "app.agent.turn.state": "running"
+              },
+              "Failed to record running turn summary"
+            );
+          });
+        }
         setTags({
           conversationId
         });
@@ -20070,15 +20051,16 @@ function createReplyToThread(deps) {
         await persistThreadState(thread, {
           conversation: preparedState.conversation
         });
-        const fallbackIdentity = await deps.services.lookupSlackUser(
-          message.author.userId
-        );
         const resolvedUserName = message.author.userName ?? fallbackIdentity?.userName;
         if (resolvedUserName) {
           setTags({ slackUserName: resolvedUserName });
         }
+        const turnAttachments = collectTurnAttachments(
+          message,
+          options.queuedMessages
+        );
         const userAttachments = await deps.resolveUserAttachments(
-          message.attachments,
+          turnAttachments,
           {
             threadId,
             requesterId: message.author.userId,
@@ -20088,7 +20070,7 @@ function createReplyToThread(deps) {
             messageTs: slackMessageTs
           }
         );
-        const omittedImageAttachmentCount = !isVisionEnabled() && hasPotentialImageAttachment(message.attachments) ? countPotentialImageAttachments(message.attachments) : 0;
+        const omittedImageAttachmentCount = !isVisionEnabled() && hasPotentialImageAttachment(turnAttachments) ? countPotentialImageAttachments(turnAttachments) : 0;
         const status = createSlackAdapterAssistantStatusSession({
           channelId: assistantThreadContext?.channelId,
           threadTs: assistantThreadContext?.threadTs,
@@ -20123,11 +20105,10 @@ function createReplyToThread(deps) {
           const loadedPiMessages = await loadPiMessagesForTurn({
             conversationId,
             activeTurnId,
-            lastSessionId: lastSessionIdForHistory,
             fallback: preparedState.conversation.piMessages
           });
           let piMessages = loadedPiMessages.piMessages;
-          if (conversationId && loadedPiMessages.compactionSessionId && piMessages?.length) {
+          if (conversationId && loadedPiMessages.canCompact && piMessages?.length) {
             const compaction = await deps.services.contextCompactor.maybeCompact({
               conversation: preparedState.conversation,
               conversationContext: preparedState.routingContext ?? preparedState.conversationContext,
@@ -20139,7 +20120,7 @@ function createReplyToThread(deps) {
                 runId
               },
               onCompactionStart: () => status.start(compactingStatus),
-              previousSessionId: loadedPiMessages.compactionSessionId
+              piMessages
             });
             if (compaction.compacted) {
               piMessages = compaction.piMessages;
@@ -20163,61 +20144,65 @@ function createReplyToThread(deps) {
             threadId
           });
           const toolChannelId = preparedState.artifacts.assistantContextChannelId ?? channelId;
-          let reply = await deps.services.generateAssistantReply(userText, {
-            requester: {
-              userId: message.author.userId,
-              userName: message.author.userName ?? fallbackIdentity?.userName,
-              fullName: message.author.fullName ?? fallbackIdentity?.fullName,
-              email: fallbackIdentity?.email
-            },
-            conversationContext: preparedState.routingContext ?? preparedState.conversationContext,
-            artifactState: preparedState.artifacts,
-            piMessages,
-            pendingAuth: preparedState.conversation.processing.pendingAuth,
-            configuration: preparedState.configuration,
-            channelConfiguration: preparedState.channelConfiguration,
-            inboundAttachmentCount: message.attachments.length,
-            omittedImageAttachmentCount,
-            userAttachments,
-            correlation: {
-              conversationId,
-              threadId,
-              turnId,
-              threadTs,
-              messageTs,
-              teamId,
-              runId,
-              channelId,
-              requesterId: message.author.userId
-            },
-            toolChannelId,
-            sandbox: {
-              sandboxId: preparedState.sandboxId,
-              sandboxDependencyProfileHash: preparedState.sandboxDependencyProfileHash
-            },
-            onSandboxAcquired: async (sandbox) => {
-              await persistThreadState(thread, {
-                sandboxId: sandbox.sandboxId,
-                sandboxDependencyProfileHash: sandbox.sandboxDependencyProfileHash
-              });
-            },
-            onArtifactStateUpdated: async (artifacts) => {
-              latestArtifacts = artifacts;
-              await persistThreadState(thread, { artifacts });
-            },
-            onAuthPending: async (pendingAuth) => {
-              await applyPendingAuthUpdate({
-                conversation: preparedState.conversation,
+          let reply = await deps.services.generateAssistantReply(
+            effectiveUserText,
+            {
+              requester: {
+                userId: message.author.userId,
+                userName: message.author.userName ?? fallbackIdentity?.userName,
+                fullName: message.author.fullName ?? fallbackIdentity?.fullName,
+                email: fallbackIdentity?.email
+              },
+              conversationContext: preparedState.routingContext ?? preparedState.conversationContext,
+              artifactState: preparedState.artifacts,
+              piMessages,
+              pendingAuth: preparedState.conversation.processing.pendingAuth,
+              configuration: preparedState.configuration,
+              channelConfiguration: preparedState.channelConfiguration,
+              inboundAttachmentCount: turnAttachments.length,
+              omittedImageAttachmentCount,
+              userAttachments,
+              correlation: {
                 conversationId,
-                nextPendingAuth: pendingAuth
-              });
-              await persistThreadState(thread, {
-                conversation: preparedState.conversation
-              });
-            },
-            onStatus: (nextStatus) => status.update(nextStatus),
-            onToolInvocation: options.onToolInvocation
-          });
+                threadId,
+                turnId,
+                threadTs,
+                messageTs,
+                teamId,
+                runId,
+                channelId,
+                channelName,
+                requesterId: message.author.userId
+              },
+              toolChannelId,
+              sandbox: {
+                sandboxId: preparedState.sandboxId,
+                sandboxDependencyProfileHash: preparedState.sandboxDependencyProfileHash
+              },
+              onSandboxAcquired: async (sandbox) => {
+                await persistThreadState(thread, {
+                  sandboxId: sandbox.sandboxId,
+                  sandboxDependencyProfileHash: sandbox.sandboxDependencyProfileHash
+                });
+              },
+              onArtifactStateUpdated: async (artifacts) => {
+                latestArtifacts = artifacts;
+                await persistThreadState(thread, { artifacts });
+              },
+              onAuthPending: async (pendingAuth) => {
+                await applyPendingAuthUpdate({
+                  conversation: preparedState.conversation,
+                  conversationId,
+                  nextPendingAuth: pendingAuth
+                });
+                await persistThreadState(thread, {
+                  conversation: preparedState.conversation
+                });
+              },
+              onStatus: (nextStatus) => status.update(nextStatus),
+              onToolInvocation: options.onToolInvocation
+            }
+          );
           const diagnosticsContext = {
             slackThreadId: threadId,
             slackUserId: message.author.userId,
@@ -20305,7 +20290,10 @@ function createReplyToThread(deps) {
           }
           const titleUpdateResult = await assistantTitleTask;
           if (titleUpdateResult) {
-            artifactStatePatch.assistantTitleSourceMessageId = titleUpdateResult;
+            artifactStatePatch.assistantTitleSourceMessageId = titleUpdateResult.sourceMessageId;
+            if (titleUpdateResult.title) {
+              artifactStatePatch.assistantTitle = titleUpdateResult.title;
+            }
           }
           const completedState = buildDeliveredTurnStatePatch({
             artifactStatePatch,
@@ -20318,6 +20306,21 @@ function createReplyToThread(deps) {
           await persistThreadState(thread, {
             ...completedState
           });
+          if (conversationId) {
+            await recordAgentTurnSessionSummary({
+              channelName,
+              conversationId,
+              cumulativeDurationMs: reply.diagnostics.durationMs,
+              cumulativeUsage: reply.diagnostics.usage,
+              sessionId: turnId,
+              sliceId: 1,
+              startedAtMs: message.metadata.dateSent.getTime(),
+              state: "completed",
+              conversationTitle: titleUpdateResult?.title,
+              requester,
+              traceId: getActiveTraceId()
+            });
+          }
           preparedState.conversation = completedState.conversation;
           persistedAtLeastOnce = true;
           if (shouldEmitDevAgentTrace()) {
@@ -20349,14 +20352,14 @@ function createReplyToThread(deps) {
           if (isRetryableTurnError(error, "turn_timeout_resume")) {
             const conversationIdForResume = error.metadata?.conversationId;
             const sessionIdForResume = error.metadata?.sessionId;
-            const checkpointVersion = error.metadata?.checkpointVersion;
+            const version = error.metadata?.version;
             const nextSliceId = error.metadata?.sliceId;
-            if (conversationIdForResume && sessionIdForResume && typeof checkpointVersion === "number" && canScheduleTurnTimeoutResume(nextSliceId)) {
+            if (conversationIdForResume && sessionIdForResume && typeof version === "number" && canScheduleTurnTimeoutResume(nextSliceId)) {
               try {
                 await deps.services.scheduleTurnTimeoutResume({
                   conversationId: conversationIdForResume,
                   sessionId: sessionIdForResume,
-                  expectedCheckpointVersion: checkpointVersion
+                  expectedVersion: version
                 });
                 shouldPersistFailureState = false;
               } catch (scheduleError) {
@@ -20366,7 +20369,7 @@ function createReplyToThread(deps) {
                   turnTraceContext,
                   {
                     ...messageTs ? { "messaging.message.id": messageTs } : {},
-                    "app.ai.resume_checkpoint_version": checkpointVersion
+                    "app.ai.resume_session_version": version
                   },
                   "Failed to schedule timeout resume callback"
                 );
@@ -20375,7 +20378,7 @@ function createReplyToThread(deps) {
               }
               await postTurnContinuationNotice();
               return;
-            } else if (conversationIdForResume && sessionIdForResume && typeof checkpointVersion === "number") {
+            } else if (conversationIdForResume && sessionIdForResume && typeof version === "number") {
               logWarn(
                 "agent_turn_timeout_resume_slice_limit_reached",
                 turnTraceContext,
@@ -20465,18 +20468,35 @@ function createReplyToThread(deps) {
             });
             if (conversationId) {
               try {
-                await failAgentTurnSessionCheckpoint({
+                await recordAgentTurnSessionSummary({
+                  channelName,
                   conversationId,
                   sessionId: turnId,
-                  errorMessage: "Agent turn failed before final reply delivery completed"
+                  sliceId: 1,
+                  startedAtMs: message.metadata.dateSent.getTime(),
+                  state: "failed",
+                  requester,
+                  traceId: getActiveTraceId()
                 });
-              } catch (checkpointError) {
+                const sessionRecord = await getAgentTurnSessionRecord(
+                  conversationId,
+                  turnId
+                );
+                if (sessionRecord) {
+                  await failAgentTurnSessionRecord({
+                    conversationId,
+                    expectedVersion: sessionRecord.version,
+                    sessionId: turnId,
+                    errorMessage: "Agent turn failed before final reply delivery completed"
+                  });
+                }
+              } catch (recordError) {
                 logException(
-                  checkpointError,
-                  "agent_turn_failed_checkpoint_persist_failed",
+                  recordError,
+                  "agent_turn_failed_session_record_persist_failed",
                   turnTraceContext,
                   {},
-                  "Failed to mark failed turn checkpoint"
+                  "Failed to mark failed turn session record"
                 );
               }
             }
@@ -20533,35 +20553,51 @@ async function refreshAssistantThreadContext(event) {
   await syncAssistantThreadContext(event, { setInitialTitle: false });
 }
 
-// src/chat/runtime/turn-preparation.ts
-var BACKFILL_MESSAGE_LIMIT = 80;
-function hasPendingImageHydration(conversation) {
-  return conversation.messages.some(
-    (message) => isHumanConversationMessage(message) && !message.meta?.imagesHydrated
+// src/chat/runtime/conversation-message.ts
+var NON_TEXT_MESSAGE_TEXT = "[non-text message]";
+function resolveMessageText(args) {
+  const text = normalizeConversationText(args.text);
+  return text || NON_TEXT_MESSAGE_TEXT;
+}
+function toConversationMessage(args) {
+  const messageHasPotentialImageAttachment = hasPotentialImageAttachment(
+    args.entry.attachments
   );
-}
-function createConversationMessageFromSdkMessage(entry) {
-  const enrichedText = appendSlackLegacyAttachmentText(entry.text, entry.raw);
-  const rawText = normalizeConversationText(enrichedText);
-  if (!rawText) {
-    return null;
-  }
+  const imageAttachmentCount = messageHasPotentialImageAttachment ? countPotentialImageAttachments(args.entry.attachments) : 0;
   return {
-    id: entry.id,
-    role: entry.author.isMe ? "assistant" : "user",
-    text: rawText,
-    createdAtMs: entry.metadata.dateSent.getTime(),
+    id: args.entry.id,
+    role: args.entry.author.isMe ? "assistant" : "user",
+    text: resolveMessageText(args),
+    createdAtMs: args.entry.metadata.dateSent.getTime(),
     author: {
-      userId: entry.author.userId,
-      userName: entry.author.userName,
-      fullName: entry.author.fullName,
-      isBot: typeof entry.author.isBot === "boolean" ? entry.author.isBot : void 0
+      userId: args.entry.author.userId,
+      userName: args.entry.author.userName,
+      fullName: args.entry.author.fullName,
+      isBot: typeof args.entry.author.isBot === "boolean" ? args.entry.author.isBot : void 0
     },
     meta: {
-      slackTs: getSlackMessageTs(entry)
+      attachmentCount: args.entry.attachments.length,
+      explicitMention: args.explicitMention,
+      imageAttachmentCount: imageAttachmentCount > 0 ? imageAttachmentCount : void 0,
+      imagesHydrated: !messageHasPotentialImageAttachment,
+      slackTs: getSlackMessageTs(args.entry)
     }
   };
 }
+
+// src/chat/runtime/turn-preparation.ts
+var BACKFILL_MESSAGE_LIMIT = 80;
+function hasPendingImageHydration(conversation) {
+  return conversation.messages.some(
+    (message) => isHumanConversationMessage(message) && !message.meta?.imagesHydrated
+  );
+}
+function getBackfillText(entry) {
+  const text = normalizeConversationText(
+    appendSlackLegacyAttachmentText(entry.text, entry.raw)
+  );
+  return text || void 0;
+}
 async function seedConversationBackfill(thread, conversation, currentTurn) {
   if (conversation.backfill.completedAtMs) {
     return;
@@ -20586,9 +20622,9 @@ async function seedConversationBackfill(thread, conversation, currentTurn) {
     }
     fetchedNewestFirst.reverse();
     for (const entry of fetchedNewestFirst) {
-      const message = createConversationMessageFromSdkMessage(entry);
-      if (message) {
-        seeded.push(message);
+      const text = getBackfillText(entry);
+      if (text) {
+        seeded.push(toConversationMessage({ entry, text }));
       }
     }
     if (seeded.length > 0) {
@@ -20603,9 +20639,9 @@ async function seedConversationBackfill(thread, conversation, currentTurn) {
     }
     const fromRecent = thread.recentMessages.slice(-BACKFILL_MESSAGE_LIMIT);
     for (const entry of fromRecent) {
-      const message = createConversationMessageFromSdkMessage(entry);
-      if (message) {
-        seeded.push(message);
+      const text = getBackfillText(entry);
+      if (text) {
+        seeded.push(toConversationMessage({ entry, text }));
       }
     }
     source = "recent_messages";
@@ -20642,35 +20678,26 @@ function createPrepareTurnState(deps) {
       messageId: args.message.id,
       messageCreatedAtMs: args.message.metadata.dateSent.getTime()
     });
-    const messageHasPotentialImageAttachment = hasPotentialImageAttachment(
-      args.message.attachments
-    );
-    const imageAttachmentCount = messageHasPotentialImageAttachment ? countPotentialImageAttachments(args.message.attachments) : 0;
-    const normalizedUserText = normalizeConversationText(args.userText) || "[non-text message]";
-    const slackTs = getSlackMessageTs(args.message);
-    const incomingUserMessage = {
-      id: args.message.id,
-      role: "user",
-      text: normalizedUserText,
-      createdAtMs: args.message.metadata.dateSent.getTime(),
-      author: {
-        userId: args.message.author.userId,
-        userName: args.message.author.userName,
-        fullName: args.message.author.fullName,
-        isBot: typeof args.message.author.isBot === "boolean" ? args.message.author.isBot : void 0
-      },
-      meta: {
-        attachmentCount: args.message.attachments.length,
-        explicitMention: args.explicitMention,
-        imageAttachmentCount: imageAttachmentCount > 0 ? imageAttachmentCount : void 0,
-        slackTs,
-        imagesHydrated: !messageHasPotentialImageAttachment
-      }
-    };
+    for (const queued of args.queuedMessages ?? []) {
+      const queuedMessage = toConversationMessage({
+        entry: queued.message,
+        explicitMention: queued.explicitMention,
+        text: queued.userText
+      });
+      upsertConversationMessage(conversation, queuedMessage);
+    }
+    const incomingUserMessage = toConversationMessage({
+      entry: args.message,
+      explicitMention: args.explicitMention,
+      text: args.text.userText
+    });
     const userMessageId = upsertConversationMessage(
       conversation,
       incomingUserMessage
     );
+    const messageHasPotentialImageAttachment = hasPotentialImageAttachment(args.message.attachments) || (args.queuedMessages ?? []).some(
+      (queued) => hasPotentialImageAttachment(queued.message.attachments)
+    );
     const shouldHydrateVisionContext = !conversation.vision.backfillCompletedAtMs || messageHasPotentialImageAttachment || hasPendingImageHydration(conversation);
     if (isVisionEnabled() && shouldHydrateVisionContext) {
       await deps.hydrateConversationVisionContext(conversation, {
@@ -20757,28 +20784,20 @@ function createSlackRuntime(options) {
       message,
       decision,
       completedAtMs,
-      userText
+      text
     }) => {
       const conversation = coerceThreadConversationState(await thread.state);
-      const normalizedUserText = normalizeConversationText(userText) || "[non-text message]";
-      const slackTs = getSlackMessageTs(message);
+      const conversationMessage = toConversationMessage({
+        entry: message,
+        explicitMention: Boolean(message.isMention),
+        text: text.userText
+      });
       upsertConversationMessage(conversation, {
-        id: message.id,
-        role: "user",
-        text: normalizedUserText,
-        createdAtMs: message.metadata.dateSent.getTime(),
-        author: {
-          userId: message.author.userId,
-          userName: message.author.userName,
-          fullName: message.author.fullName,
-          isBot: typeof message.author.isBot === "boolean" ? message.author.isBot : void 0
-        },
+        ...conversationMessage,
         meta: {
-          explicitMention: Boolean(message.isMention),
-          slackTs,
+          ...conversationMessage.meta,
           replied: false,
-          skippedReason: decision.reason,
-          imagesHydrated: !hasPotentialImageAttachment(message.attachments)
+          skippedReason: decision.reason
         }
       });
       conversation.processing.activeTurnId = void 0;
@@ -21221,17 +21240,26 @@ function createProductionBot() {
   });
 }
 function registerProductionHandlers(bot, slackRuntime) {
-  bot.onNewMention((thread, message) => {
+  bot.onNewMention((thread, message, context) => {
     rehydrateAttachmentFetchers(message);
-    return slackRuntime.handleNewMention(thread, message);
+    context?.skipped.forEach((skipped) => rehydrateAttachmentFetchers(skipped));
+    return slackRuntime.handleNewMention(thread, message, {
+      messageContext: context
+    });
   });
-  bot.onDirectMessage((thread, message) => {
+  bot.onDirectMessage((thread, message, _channel, context) => {
     rehydrateAttachmentFetchers(message);
-    return slackRuntime.handleNewMention(thread, message);
+    context?.skipped.forEach((skipped) => rehydrateAttachmentFetchers(skipped));
+    return slackRuntime.handleNewMention(thread, message, {
+      messageContext: context
+    });
   });
-  bot.onSubscribedMessage((thread, message) => {
+  bot.onSubscribedMessage((thread, message, context) => {
     rehydrateAttachmentFetchers(message);
-    return slackRuntime.handleSubscribedMessage(thread, message);
+    context?.skipped.forEach((skipped) => rehydrateAttachmentFetchers(skipped));
+    return slackRuntime.handleSubscribedMessage(thread, message, {
+      messageContext: context
+    });
   });
   bot.onAssistantThreadStarted(
     (event) => slackRuntime.handleAssistantThreadStarted(event)
@@ -21718,14 +21746,13 @@ async function createApp(options) {
     }
     await next();
   });
-  app.get("/", () => GET3());
-  app.get("/health", () => GET2());
-  app.get("/api/info", () => GET());
+  app.get("/", () => GET());
+  app.get("/health", () => GET());
   app.get("/api/oauth/callback/mcp/:provider", (c) => {
-    return GET5(c.req.raw, c.req.param("provider"), waitUntil);
+    return GET3(c.req.raw, c.req.param("provider"), waitUntil);
   });
   app.get("/api/oauth/callback/:provider", (c) => {
-    return GET6(c.req.raw, c.req.param("provider"), waitUntil);
+    return GET4(c.req.raw, c.req.param("provider"), waitUntil);
   });
   app.post("/api/internal/turn-resume", (c) => {
     return POST2(c.req.raw, waitUntil);
@@ -21734,7 +21761,7 @@ async function createApp(options) {
     return POST(c.req.raw, waitUntil);
   });
   app.get("/api/internal/heartbeat", (c) => {
-    return GET4(c.req.raw, waitUntil);
+    return GET2(c.req.raw, waitUntil);
   });
   app.post("/api/webhooks/:platform", (c) => {
     return POST3(c.req.raw, c.req.param("platform"), waitUntil);