@sentry/junior 0.52.0 → 0.54.0

package/dist/app.js

@@ -3,8 +3,9 @@ import {
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-ZNFNY53B.js";
+} from "./chunk-QCHPJ4FD.js";
 import {
+  ACTIVE_LOCK_TTL_MS,
   GEN_AI_PROVIDER_NAME,
   MISSING_GATEWAY_CREDENTIALS_ERROR,
   SANDBOX_DATA_ROOT,
@@ -31,7 +32,7 @@ import {
   runNonInteractiveCommand,
   sandboxSkillDir,
   sandboxSkillFile
-} from "./chunk-KCOKQLBF.js";
+} from "./chunk-7WTXNEPF.js";
 import {
   CredentialUnavailableError,
   buildOAuthTokenRequest,
@@ -48,6 +49,7 @@ import {
   getPluginDefinition,
   getPluginMcpProviders,
   getPluginOAuthConfig,
+  getPluginPackageContent,
   getPluginProviders,
   hasRequiredOAuthScope,
   isPluginConfigKey,
@@ -70,18 +72,16 @@ import {
   toOptionalString,
   withContext,
   withSpan
-} from "./chunk-Q3FDONU7.js";
+} from "./chunk-YITDDLS3.js";
 import {
   sentry_exports
 } from "./chunk-Z3YD6NHK.js";
 import {
-  discoverInstalledPluginPackageContent,
   homeDir,
   listReferenceFiles,
-  setPluginPackages,
   soulPathCandidates,
   worldPathCandidates
-} from "./chunk-XPXD3FCE.js";
+} from "./chunk-5LUISFEY.js";
 import "./chunk-2KG3PWR4.js";
 
 // src/app.ts
@@ -89,11 +89,22 @@ import { Hono } from "hono";
 
 // src/chat/configuration/defaults.ts
 var installDefaults = {};
+function cloneDefaults(defaults) {
+  return structuredClone(defaults);
+}
+function isConfigDefaultsRecord(defaults) {
+  return typeof defaults === "object" && defaults !== null && !Array.isArray(defaults);
+}
 function setConfigDefaults(defaults) {
-  if (!defaults) {
+  if (defaults === void 0) {
     installDefaults = {};
     return;
   }
+  if (!isConfigDefaultsRecord(defaults)) {
+    throw new Error(
+      "configDefaults must be an object keyed by plugin config key"
+    );
+  }
   for (const key of Object.keys(defaults)) {
     if (!isPluginConfigKey(key)) {
       throw new Error(
@@ -101,10 +112,10 @@ function setConfigDefaults(defaults) {
       );
     }
   }
-  installDefaults = { ...defaults };
+  installDefaults = cloneDefaults(defaults);
 }
 function getConfigDefaults() {
-  return installDefaults;
+  return cloneDefaults(installDefaults);
 }
 
 // src/handlers/diagnostics.ts
@@ -122,7 +133,7 @@ function readDescriptionText() {
   }
 }
 async function GET() {
-  const packagedContent = discoverInstalledPluginPackageContent();
+  const packagedContent = getPluginPackageContent();
   const skills = await discoverSkills();
   return Response.json({
     cwd: process.cwd(),
@@ -494,6 +505,7 @@ 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 : {};
@@ -1478,6 +1490,9 @@ var StateBackedMcpOAuthClientProvider = class {
     this.sessionContext = sessionContext;
     this.clientMetadata = createClientMetadata(callbackUrl);
   }
+  authSessionId;
+  callbackUrl;
+  sessionContext;
   clientMetadata;
   get redirectUrl() {
     return this.callbackUrl;
@@ -2101,17 +2116,24 @@ function startActiveTurn(args) {
   args.conversation.processing.activeTurnId = args.nextTurnId;
   args.updateConversationStats(args.conversation);
 }
-function markTurnCompleted(args) {
-  if (!args.sessionId || args.conversation.processing.activeTurnId === args.sessionId) {
-    args.conversation.processing.activeTurnId = void 0;
+function clearActiveTurn(conversation, sessionId) {
+  if (!sessionId || conversation.processing.activeTurnId === sessionId) {
+    conversation.processing.activeTurnId = void 0;
   }
+}
+function markTurnClosed(args) {
+  clearActiveTurn(args.conversation, args.sessionId);
+  args.conversation.processing.lastCompletedAtMs = args.nowMs;
+  args.updateConversationStats(args.conversation);
+}
+function markTurnCompleted(args) {
+  clearActiveTurn(args.conversation, args.sessionId);
+  args.conversation.processing.lastSessionId = args.sessionId;
   args.conversation.processing.lastCompletedAtMs = args.nowMs;
   args.updateConversationStats(args.conversation);
 }
 function markTurnFailed(args) {
-  if (!args.sessionId || args.conversation.processing.activeTurnId === args.sessionId) {
-    args.conversation.processing.activeTurnId = void 0;
-  }
+  clearActiveTurn(args.conversation, args.sessionId);
   args.conversation.processing.lastCompletedAtMs = args.nowMs;
   args.markConversationMessage(args.conversation, args.userMessageId, {
     replied: false,
@@ -2120,39 +2142,6 @@ function markTurnFailed(args) {
   args.updateConversationStats(args.conversation);
 }
 
-// src/chat/runtime/turn-user-message.ts
-function normalizeSlackMessageTs(value) {
-  const trimmed = value?.trim();
-  return trimmed && /^\d+(?:\.\d+)?$/.test(trimmed) ? trimmed : void 0;
-}
-function getTurnUserMessage(conversation, sessionId) {
-  for (let index = conversation.messages.length - 1; index >= 0; index -= 1) {
-    const message = conversation.messages[index];
-    if (message?.role !== "user") {
-      continue;
-    }
-    if (buildDeterministicTurnId(message.id) === sessionId) {
-      return message;
-    }
-  }
-  return void 0;
-}
-function getTurnUserMessageId(conversation, sessionId) {
-  return getTurnUserMessage(conversation, sessionId)?.id;
-}
-function getTurnUserSlackMessageTs(message) {
-  return normalizeSlackMessageTs(message?.meta?.slackTs) ?? normalizeSlackMessageTs(message?.id);
-}
-function getTurnUserReplyAttachmentContext(message) {
-  const inboundAttachmentCount = message?.meta?.attachmentCount ?? 0;
-  const imageAttachmentCount = message?.meta?.imageAttachmentCount ?? 0;
-  const imagesHydrated = message?.meta?.imagesHydrated === true;
-  return {
-    ...inboundAttachmentCount > 0 ? { inboundAttachmentCount } : {},
-    ...!imagesHydrated && imageAttachmentCount > 0 ? { omittedImageAttachmentCount: imageAttachmentCount } : {}
-  };
-}
-
 // src/chat/services/conversation-memory.ts
 var CONTEXT_COMPACTION_TRIGGER_TOKENS = 9e3;
 var CONTEXT_COMPACTION_TARGET_TOKENS = 7e3;
@@ -2443,141 +2432,578 @@ function getConversationMessageSlackTs(message) {
   return message.meta?.slackTs ?? toOptionalString(message.id);
 }
 
-// src/chat/respond.ts
-import { Agent as Agent2 } from "@mariozechner/pi-agent-core";
-
-// src/chat/prompt.ts
-import fs from "fs";
-import path2 from "path";
+// src/chat/state/turn-session-store.ts
+import { THREAD_STATE_TTL_MS as THREAD_STATE_TTL_MS2 } from "chat";
 
-// src/chat/interruption-marker.ts
-var INTERRUPTED_MARKER = "\n\n[Response interrupted before completion]";
-function getInterruptionMarker() {
-  return INTERRUPTED_MARKER;
+// 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;
 }
-
-// src/chat/slack/status-format.ts
-var SLACK_STATUS_MAX_LENGTH = 50;
-function truncateStatusText(text) {
-  const trimmed = text.trim();
-  if (!trimmed) {
-    return "";
+async function loadPiSessionMessages(args) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  const messageCount = normalizeMessageCount(args.messageCount);
+  if (messageCount === 0) {
+    return [];
   }
-  if (trimmed.length <= SLACK_STATUS_MAX_LENGTH) {
-    return trimmed;
+  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 `${trimmed.slice(0, SLACK_STATUS_MAX_LENGTH - 3).trimEnd()}...`;
+  return messages.length === messageCount ? messages : void 0;
 }
-
-// src/chat/slack/mrkdwn.ts
-function ensureBlockSpacing(text) {
-  const codeBlockPattern = /^```/;
-  const listItemPattern = /^[-*•]\s|^\d+\.\s/;
-  const lines = text.split("\n");
-  const result = [];
-  let inCodeBlock = false;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const isCodeFence = codeBlockPattern.test(line.trimStart());
-    if (isCodeFence) {
-      if (!inCodeBlock) {
-        const prev2 = result.length > 0 ? result[result.length - 1] : void 0;
-        if (prev2 !== void 0 && prev2.trim() !== "") {
-          result.push("");
-        }
-      }
-      inCodeBlock = !inCodeBlock;
-      result.push(line);
-      continue;
-    }
-    if (inCodeBlock) {
-      result.push(line);
-      continue;
-    }
-    const prev = result.length > 0 ? result[result.length - 1] : void 0;
-    if (prev !== void 0 && prev.trim() !== "" && line.trim() !== "" && !(listItemPattern.test(prev.trimStart()) && listItemPattern.test(line.trimStart()))) {
-      result.push("");
+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;
     }
-    result.push(line);
+    messages.push(message);
   }
-  return result.join("\n");
-}
-function renderSlackMrkdwn(text) {
-  let normalized = text.replace(/\r\n?/g, "\n").replace(/[ \t]+$/gm, "");
-  normalized = ensureBlockSpacing(normalized);
-  return normalized.replace(/\n{3,}/g, "\n\n").trim();
+  return messages;
 }
-function normalizeSlackStatusText(text) {
-  const trimmed = text.trim();
-  if (!trimmed) {
-    return "";
-  }
-  return truncateStatusText(trimmed.replace(/(?:\.\s*)+$/, "").trim());
+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/slack/output.ts
-var MAX_INLINE_CHARS = 2200;
-var MAX_INLINE_LINES = 45;
-var CONTINUED_MARKER = "\n\n[Continued below]";
-function countSlackLines(text) {
-  if (!text) {
-    return 0;
-  }
-  return text.split("\n").length;
+// 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 fitsInlineBudget(text, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
-  return text.length <= maxChars && countSlackLines(text) <= maxLines;
+function toFiniteNonNegativeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : void 0;
 }
-function findSplitIndex(text, maxChars) {
-  if (text.length <= maxChars) {
-    return text.length;
-  }
-  const bounded = text.slice(0, maxChars);
-  const newlineIndex = bounded.lastIndexOf("\n");
-  if (newlineIndex > 0) {
-    return newlineIndex;
+function parseAgentTurnUsage(value) {
+  if (!isRecord(value)) {
+    return void 0;
   }
-  const spaceIndex = bounded.lastIndexOf(" ");
-  if (spaceIndex > 0) {
-    return spaceIndex;
+  const usage = {};
+  for (const field of [
+    "inputTokens",
+    "outputTokens",
+    "cachedInputTokens",
+    "cacheCreationTokens",
+    "totalTokens"
+  ]) {
+    const count = toFiniteNonNegativeNumber(value[field]);
+    if (count !== void 0) {
+      usage[field] = count;
+    }
   }
-  return maxChars;
+  return Object.keys(usage).length > 0 ? usage : void 0;
 }
-function splitByLineBudget(text, maxLines) {
-  if (maxLines <= 0) {
-    return "";
+function parseStoredRecord(value) {
+  if (isRecord(value)) {
+    return value;
   }
-  const lines = text.split("\n");
-  if (lines.length <= maxLines) {
-    return text;
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(value);
+    return isRecord(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
   }
-  return lines.slice(0, maxLines).join("\n");
 }
-function reserveInlineBudgetForSuffix(suffix, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
+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 {
-    maxChars: Math.max(1, maxChars - suffix.length),
-    maxLines: Math.max(1, maxLines - Math.max(0, countSlackLines(suffix) - 1))
+    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 forceSplitBudget(text, budget) {
-  const lineCount = countSlackLines(text);
+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 {
-    maxChars: text.length <= budget.maxChars ? Math.max(1, text.length - 1) : budget.maxChars,
-    maxLines: lineCount <= budget.maxLines ? Math.max(1, lineCount - 1) : budget.maxLines
+    ...parsed.record,
+    piMessages
   };
 }
-function getFenceContinuation(text) {
-  let open;
-  for (const line of text.split("\n")) {
-    const trimmed = line.trimStart();
-    const openerMatch = trimmed.match(/^(`{3,}|~{3,})(.*)$/);
-    if (!openerMatch) {
-      continue;
-    }
-    if (!open) {
-      open = {
-        fence: openerMatch[1],
-        openerLine: trimmed
+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) {
+  const { pendingAuth } = args;
+  if (!pendingAuth) {
+    return false;
+  }
+  return pendingAuth.kind === args.kind && pendingAuth.provider === args.provider && pendingAuth.requesterId === args.requesterId && pendingAuth.linkSentAtMs + AUTH_LINK_REUSE_WINDOW_MS > (args.nowMs ?? Date.now());
+}
+function getConversationPendingAuth(args) {
+  const pendingAuth = args.conversation.processing.pendingAuth;
+  if (!pendingAuth) {
+    return void 0;
+  }
+  if (pendingAuth.kind !== args.kind || pendingAuth.provider !== args.provider || pendingAuth.requesterId !== args.requesterId) {
+    return void 0;
+  }
+  return pendingAuth;
+}
+function clearPendingAuth(conversation, sessionId) {
+  if (!conversation.processing.pendingAuth) {
+    return;
+  }
+  if (sessionId && conversation.processing.pendingAuth.sessionId !== sessionId) {
+    return;
+  }
+  conversation.processing.pendingAuth = void 0;
+}
+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({
+      conversationId: args.conversationId,
+      sessionId: previousPendingAuth.sessionId,
+      errorMessage: "Superseded by a newer auth-blocked request in the same conversation."
+    });
+  }
+}
+function isPendingAuthLatestRequest(conversation, pendingAuth) {
+  for (let index = conversation.messages.length - 1; index >= 0; index -= 1) {
+    const message = conversation.messages[index];
+    if (message?.role !== "user") {
+      continue;
+    }
+    return buildDeterministicTurnId(message.id) === pendingAuth.sessionId;
+  }
+  return false;
+}
+
+// src/chat/runtime/delivered-turn-state.ts
+function buildDeliveredTurnStatePatch(args) {
+  const conversation = structuredClone(args.conversation);
+  const artifactStatePatch = {
+    ...args.reply.artifactStatePatch ?? {},
+    ...args.artifactStatePatch ?? {}
+  };
+  const artifacts = Object.keys(artifactStatePatch).length > 0 ? mergeArtifactsState(args.artifacts, artifactStatePatch) : void 0;
+  clearPendingAuth(conversation, args.sessionId);
+  markConversationMessage(conversation, args.userMessageId, {
+    replied: true,
+    skippedReason: void 0
+  });
+  upsertConversationMessage(conversation, {
+    id: generateConversationId("assistant"),
+    role: "assistant",
+    text: normalizeConversationText(args.reply.text) || "[empty response]",
+    createdAtMs: Date.now(),
+    author: {
+      userName: botConfig.userName,
+      isBot: true
+    },
+    meta: {
+      replied: true
+    }
+  });
+  markTurnCompleted({
+    conversation,
+    nowMs: Date.now(),
+    sessionId: args.sessionId,
+    updateConversationStats
+  });
+  return {
+    artifacts,
+    conversation,
+    sandboxId: args.reply.sandboxId,
+    sandboxDependencyProfileHash: args.reply.sandboxDependencyProfileHash
+  };
+}
+
+// src/chat/runtime/turn-user-message.ts
+function normalizeSlackMessageTs(value) {
+  const trimmed = value?.trim();
+  return trimmed && /^\d+(?:\.\d+)?$/.test(trimmed) ? trimmed : void 0;
+}
+function getTurnUserMessage(conversation, sessionId) {
+  for (let index = conversation.messages.length - 1; index >= 0; index -= 1) {
+    const message = conversation.messages[index];
+    if (message?.role !== "user") {
+      continue;
+    }
+    if (buildDeterministicTurnId(message.id) === sessionId) {
+      return message;
+    }
+  }
+  return void 0;
+}
+function getTurnUserMessageId(conversation, sessionId) {
+  return getTurnUserMessage(conversation, sessionId)?.id;
+}
+function getTurnUserSlackMessageTs(message) {
+  return normalizeSlackMessageTs(message?.meta?.slackTs) ?? normalizeSlackMessageTs(message?.id);
+}
+function getTurnUserReplyAttachmentContext(message) {
+  const inboundAttachmentCount = message?.meta?.attachmentCount ?? 0;
+  const imageAttachmentCount = message?.meta?.imageAttachmentCount ?? 0;
+  const imagesHydrated = message?.meta?.imagesHydrated === true;
+  return {
+    ...inboundAttachmentCount > 0 ? { inboundAttachmentCount } : {},
+    ...!imagesHydrated && imageAttachmentCount > 0 ? { omittedImageAttachmentCount: imageAttachmentCount } : {}
+  };
+}
+
+// src/chat/respond.ts
+import { Agent as Agent2 } from "@earendil-works/pi-agent-core";
+
+// src/chat/prompt.ts
+import fs from "fs";
+import path2 from "path";
+
+// src/chat/turn-context-tag.ts
+var TURN_CONTEXT_TAG = "runtime-turn-context";
+
+// src/chat/interruption-marker.ts
+var INTERRUPTED_MARKER = "\n\n[Response interrupted before completion]";
+function getInterruptionMarker() {
+  return INTERRUPTED_MARKER;
+}
+
+// src/chat/slack/status-format.ts
+var SLACK_STATUS_MAX_LENGTH = 50;
+function truncateStatusText(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return "";
+  }
+  if (trimmed.length <= SLACK_STATUS_MAX_LENGTH) {
+    return trimmed;
+  }
+  return `${trimmed.slice(0, SLACK_STATUS_MAX_LENGTH - 3).trimEnd()}...`;
+}
+
+// src/chat/slack/mrkdwn.ts
+function ensureBlockSpacing(text) {
+  const codeBlockPattern = /^```/;
+  const listItemPattern = /^[-*•]\s|^\d+\.\s/;
+  const lines = text.split("\n");
+  const result = [];
+  let inCodeBlock = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const isCodeFence = codeBlockPattern.test(line.trimStart());
+    if (isCodeFence) {
+      if (!inCodeBlock) {
+        const prev2 = result.length > 0 ? result[result.length - 1] : void 0;
+        if (prev2 !== void 0 && prev2.trim() !== "") {
+          result.push("");
+        }
+      }
+      inCodeBlock = !inCodeBlock;
+      result.push(line);
+      continue;
+    }
+    if (inCodeBlock) {
+      result.push(line);
+      continue;
+    }
+    const prev = result.length > 0 ? result[result.length - 1] : void 0;
+    if (prev !== void 0 && prev.trim() !== "" && line.trim() !== "" && !(listItemPattern.test(prev.trimStart()) && listItemPattern.test(line.trimStart()))) {
+      result.push("");
+    }
+    result.push(line);
+  }
+  return result.join("\n");
+}
+function renderSlackMrkdwn(text) {
+  let normalized = text.replace(/\r\n?/g, "\n").replace(/[ \t]+$/gm, "");
+  normalized = ensureBlockSpacing(normalized);
+  return normalized.replace(/\n{3,}/g, "\n\n").trim();
+}
+function normalizeSlackStatusText(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return "";
+  }
+  return truncateStatusText(trimmed.replace(/(?:\.\s*)+$/, "").trim());
+}
+
+// src/chat/slack/output.ts
+var MAX_INLINE_CHARS = 2200;
+var MAX_INLINE_LINES = 45;
+var CONTINUED_MARKER = "\n\n[Continued below]";
+function countSlackLines(text) {
+  if (!text) {
+    return 0;
+  }
+  return text.split("\n").length;
+}
+function fitsInlineBudget(text, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
+  return text.length <= maxChars && countSlackLines(text) <= maxLines;
+}
+function findSplitIndex(text, maxChars) {
+  if (text.length <= maxChars) {
+    return text.length;
+  }
+  const bounded = text.slice(0, maxChars);
+  const newlineIndex = bounded.lastIndexOf("\n");
+  if (newlineIndex > 0) {
+    return newlineIndex;
+  }
+  const spaceIndex = bounded.lastIndexOf(" ");
+  if (spaceIndex > 0) {
+    return spaceIndex;
+  }
+  return maxChars;
+}
+function splitByLineBudget(text, maxLines) {
+  if (maxLines <= 0) {
+    return "";
+  }
+  const lines = text.split("\n");
+  if (lines.length <= maxLines) {
+    return text;
+  }
+  return lines.slice(0, maxLines).join("\n");
+}
+function reserveInlineBudgetForSuffix(suffix, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
+  return {
+    maxChars: Math.max(1, maxChars - suffix.length),
+    maxLines: Math.max(1, maxLines - Math.max(0, countSlackLines(suffix) - 1))
+  };
+}
+function forceSplitBudget(text, budget) {
+  const lineCount = countSlackLines(text);
+  return {
+    maxChars: text.length <= budget.maxChars ? Math.max(1, text.length - 1) : budget.maxChars,
+    maxLines: lineCount <= budget.maxLines ? Math.max(1, lineCount - 1) : budget.maxLines
+  };
+}
+function getFenceContinuation(text) {
+  let open;
+  for (const line of text.split("\n")) {
+    const trimmed = line.trimStart();
+    const openerMatch = trimmed.match(/^(`{3,}|~{3,})(.*)$/);
+    if (!openerMatch) {
+      continue;
+    }
+    if (!open) {
+      open = {
+        fence: openerMatch[1],
+        openerLine: trimmed
       };
       continue;
     }
@@ -2859,17 +3285,17 @@ function formatAvailableSkillsForPrompt(skills, invocation) {
     (s) => s.disableModelInvocation === true && s.name === invocation.skillName
   ) : [];
   const sections = [];
-  const available = [
-    "<available-skills>",
-    ...autoSelectable.length > 0 ? [
+  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."
-    ] : []
-  ];
-  for (const skill of autoSelectable) {
-    available.push(...formatSkillEntry(skill));
+    ];
+    for (const skill of autoSelectable) {
+      available.push(...formatSkillEntry(skill));
+    }
+    available.push("</available-skills>");
+    sections.push(available.join("\n"));
   }
-  available.push("</available-skills>");
-  sections.push(available.join("\n"));
   if (invokedExplicitOnly.length > 0) {
     const userCallable = [
       "<user-callable-skills>",
@@ -2881,11 +3307,11 @@ function formatAvailableSkillsForPrompt(skills, invocation) {
     userCallable.push("</user-callable-skills>");
     sections.push(userCallable.join("\n"));
   }
-  return sections.join("\n");
+  return sections.length > 0 ? sections.join("\n") : null;
 }
 function formatLoadedSkillsForPrompt(skills) {
   if (skills.length === 0) {
-    return "<loaded-skills>\n</loaded-skills>";
+    return null;
   }
   const lines = ["<loaded-skills>"];
   for (const skill of skills) {
@@ -3010,17 +3436,8 @@ function formatConfigurationLines(configuration) {
     (key) => `- ${escapeXml(key)}: ${formatConfigurationValue(configuration?.[key])}`
   );
 }
-function formatSlackCapabilityNames(capabilities) {
-  const names = [
-    capabilities?.canCreateCanvas ? "canvas_create" : "",
-    capabilities?.canPostToChannel ? "channel_post" : "",
-    capabilities?.canAddReactions ? "reaction_add" : ""
-  ].filter(Boolean);
-  return names.length > 0 ? names.join(", ") : "none";
-}
 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_TAG = "runtime-turn-context";
 var TOOL_POLICY_RULES = [
   "- Tool schemas are the source of truth for parameters; tool names are case-sensitive, so call tools exactly by their exposed names and do not invent arguments.",
   "- Use tools for actionable work and for facts that are mutable, external, repository-backed, provider-backed, or requested as verified/current. Stable general knowledge and already-provided context may be answered directly.",
@@ -3108,16 +3525,12 @@ function buildIdentitySection() {
 }
 function buildRuntimeSection(params) {
   const lines = [
-    `- version: ${escapeXml(getRuntimeMetadata().version ?? "unknown")}`,
-    params.modelId ? `- model: ${escapeXml(params.modelId)}` : "",
-    params.fastModelId ? `- fast_model: ${escapeXml(params.fastModelId)}` : "",
-    params.thinkingLevel ? `- thinking: ${escapeXml(params.thinkingLevel)}` : "",
-    params.channelId ? "- channel: slack" : "",
-    params.channelId ? `- slack_capabilities: ${escapeXml(
-      formatSlackCapabilityNames(params.slackCapabilities)
-    )}` : "",
-    `- sandbox_workspace: ${escapeXml(SANDBOX_WORKSPACE_ROOT)}`
+    params.conversationId ? `- gen_ai.conversation.id: ${escapeXml(params.conversationId)}` : "",
+    params.traceId ? `- trace_id: ${escapeXml(params.traceId)}` : ""
   ].filter(Boolean);
+  if (lines.length === 0) {
+    return null;
+  }
   return renderTagBlock("runtime", lines.join("\n"));
 }
 function buildContextSection(params) {
@@ -3170,14 +3583,24 @@ function buildContextSection(params) {
     );
   }
   const body = blocks.map((block) => block.join("\n")).join("\n\n");
+  if (!body) {
+    return null;
+  }
   return renderTagBlock("context", body);
 }
 function buildCapabilitiesSection(params) {
   const blocks = [];
-  blocks.push(
-    formatAvailableSkillsForPrompt(params.availableSkills, params.invocation)
+  const availableSkills = formatAvailableSkillsForPrompt(
+    params.availableSkills,
+    params.invocation
   );
-  blocks.push(formatLoadedSkillsForPrompt(params.activeSkills));
+  if (availableSkills) {
+    blocks.push(availableSkills);
+  }
+  const loadedSkills = formatLoadedSkillsForPrompt(params.activeSkills);
+  if (loadedSkills) {
+    blocks.push(loadedSkills);
+  }
   const activeCatalogs = formatActiveMcpCatalogsForPrompt(
     params.activeMcpCatalogs
   );
@@ -3192,6 +3615,9 @@ function buildCapabilitiesSection(params) {
   if (providerCatalog) {
     blocks.push(renderTagBlock("providers", providerCatalog));
   }
+  if (blocks.length === 0) {
+    return null;
+  }
   return renderTagBlock("capabilities", blocks.join("\n\n"));
 }
 var STATIC_SYSTEM_PROMPT = [
@@ -3225,7 +3651,7 @@ function buildTurnContextPrompt(params) {
     }),
     buildRuntimeSection(params.runtime ?? {}),
     `</${TURN_CONTEXT_TAG}>`
-  ];
+  ].filter((section) => Boolean(section));
   return sections.join("\n\n");
 }
 
@@ -3939,6 +4365,8 @@ var PluginMcpClient = class {
     this.plugin = plugin;
     this.options = options;
   }
+  plugin;
+  options;
   client;
   lastAttemptedTransportSessionId;
   transport;
@@ -4220,6 +4648,7 @@ var McpToolManager = class {
       }
     }
   }
+  options;
   pluginsByProvider = /* @__PURE__ */ new Map();
   activeProviders = /* @__PURE__ */ new Set();
   authorizationPendingProviders = /* @__PURE__ */ new Set();
@@ -7877,11 +8306,12 @@ function createSystemTimeTool() {
 // src/chat/tools/advisor/tool.ts
 import {
   Agent
-} from "@mariozechner/pi-agent-core";
+} from "@earendil-works/pi-agent-core";
 import { Type as Type21 } from "@sinclair/typebox";
 
 // src/chat/respond-helpers.ts
 var MAX_INLINE_ATTACHMENT_BASE64_CHARS = 12e4;
+var RUNTIME_TURN_CONTEXT_START = `<${TURN_CONTEXT_TAG}>`;
 function getSessionIdentifiers(context) {
   return {
     conversationId: context.correlation?.conversationId ?? context.correlation?.threadId ?? context.correlation?.runId,
@@ -7961,44 +8391,20 @@ function summarizeMessageText(text) {
   }
   return normalized.length > 1200 ? `${normalized.slice(0, 1200)}...` : normalized;
 }
-function buildUserTurnText(userInput, conversationContext, metadata) {
+function buildUserTurnText(userInput, conversationContext) {
   const trimmedContext = conversationContext?.trim();
-  const conversationId = metadata?.sessionContext?.conversationId;
-  const traceId = metadata?.turnContext?.traceId;
-  if (!trimmedContext && !conversationId && !traceId) {
+  if (!trimmedContext) {
     return userInput;
   }
-  const sections = [];
-  if (trimmedContext) {
-    sections.push(
-      "<thread-background>",
-      trimmedContext,
-      "</thread-background>",
-      ""
-    );
-  }
-  if (conversationId) {
-    sections.push(
-      "<session-context>",
-      `- gen_ai.conversation.id: ${conversationId}`,
-      "</session-context>",
-      ""
-    );
-  }
-  if (traceId) {
-    sections.push(
-      "<turn-context>",
-      `- trace_id: ${traceId}`,
-      "</turn-context>",
-      ""
-    );
-  }
-  sections.push(
-    '<current-instruction priority="highest">',
+  return [
+    "<thread-background>",
+    trimmedContext,
+    "</thread-background>",
+    "",
+    "<current-instruction>",
     userInput,
     "</current-instruction>"
-  );
-  return sections.join("\n");
+  ].join("\n");
 }
 function encodeNonImageAttachmentForPrompt(attachment) {
   const base64 = attachment.data.toString("base64");
@@ -8037,12 +8443,81 @@ function isToolResultError(result) {
 function isAssistantMessage(value) {
   return typeof value === "object" && value !== null && value.role === "assistant";
 }
-function getPiMessageRole(value) {
-  if (!value || typeof value !== "object") {
-    return void 0;
-  }
-  const role = value.role;
-  return typeof role === "string" ? role : void 0;
+function getPiMessageRole(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const role = value.role;
+  return typeof role === "string" ? role : void 0;
+}
+function getUserMessageContent(message) {
+  const record = message;
+  return record.role === "user" && Array.isArray(record.content) ? record.content : void 0;
+}
+function isRuntimeTurnContextPart(part, marker) {
+  return part !== null && typeof part === "object" && part.type === "text" && typeof part.text === "string" && part.text.startsWith(marker);
+}
+function replaceRuntimeTurnContext(message, turnContextPrompt) {
+  const content = getUserMessageContent(message);
+  if (!content) {
+    return void 0;
+  }
+  const marker = turnContextPrompt.split("\n", 1)[0];
+  const contextIndex = content.findIndex(
+    (part) => isRuntimeTurnContextPart(part, marker)
+  );
+  if (contextIndex < 0) {
+    return void 0;
+  }
+  const nextContent = [...content];
+  nextContent[contextIndex] = {
+    ...nextContent[contextIndex],
+    text: turnContextPrompt
+  };
+  return {
+    ...message,
+    content: nextContent
+  };
+}
+function refreshRuntimeTurnContext(messages, turnContextPrompt) {
+  for (let index = 0; index < messages.length; index += 1) {
+    const updated = replaceRuntimeTurnContext(
+      messages[index],
+      turnContextPrompt
+    );
+    if (!updated) {
+      continue;
+    }
+    const nextMessages = [...messages];
+    nextMessages[index] = updated;
+    return nextMessages;
+  }
+  return [
+    ...messages,
+    {
+      role: "user",
+      content: [{ type: "text", text: turnContextPrompt }],
+      timestamp: Date.now()
+    }
+  ];
+}
+function stripRuntimeTurnContext(messages) {
+  return messages.flatMap((message) => {
+    const content = getUserMessageContent(message);
+    if (!content) {
+      return [message];
+    }
+    const nextContent = content.filter(
+      (part) => !isRuntimeTurnContextPart(part, RUNTIME_TURN_CONTEXT_START)
+    );
+    if (nextContent.length === content.length) {
+      return [message];
+    }
+    if (nextContent.length === 0) {
+      return [];
+    }
+    return [{ ...message, content: nextContent }];
+  });
 }
 function extractAssistantText(message) {
   const content = message.content ?? [];
@@ -8081,8 +8556,8 @@ function trimTrailingAssistantMessages(messages) {
 }
 
 // src/chat/tools/advisor/session-store.ts
-import { THREAD_STATE_TTL_MS as THREAD_STATE_TTL_MS2 } from "chat";
-var ADVISOR_SESSION_TTL_MS = THREAD_STATE_TTL_MS2;
+import { THREAD_STATE_TTL_MS as THREAD_STATE_TTL_MS3 } from "chat";
+var ADVISOR_SESSION_TTL_MS = THREAD_STATE_TTL_MS3;
 function cloneMessages(messages) {
   return structuredClone(messages);
 }
@@ -9057,7 +9532,7 @@ function resolveChannelCapabilities(channelId) {
 // src/chat/pi/traced-stream.ts
 import {
   streamSimple
-} from "@mariozechner/pi-ai";
+} from "@earendil-works/pi-ai";
 function buildChatStartAttributes(model, context) {
   const attributes = {
     "gen_ai.operation.name": "chat",
@@ -9142,23 +9617,18 @@ import fs4 from "fs/promises";
 import { createHmac, randomUUID as randomUUID3, timingSafeEqual } from "crypto";
 var SANDBOX_EGRESS_PROXY_PATH = "/api/internal/sandbox-egress";
 var SANDBOX_EGRESS_TOKEN_VERSION = "v1";
+var SANDBOX_EGRESS_HMAC_CONTEXT = "junior.sandbox_egress.v1";
 var SANDBOX_EGRESS_LEASE_PREFIX = "sandbox-egress-lease";
 var DEFAULT_SESSION_TTL_MS = 30 * 60 * 1e3;
 function leaseKey(provider, context) {
   return `${SANDBOX_EGRESS_LEASE_PREFIX}:${provider}:${context.requesterId}:${context.egressId}:${context.contextId}`;
 }
 function getSandboxEgressSecret() {
-  const explicit = process.env.JUNIOR_SANDBOX_EGRESS_SECRET?.trim();
-  if (explicit) {
-    return explicit;
+  const secret = process.env.JUNIOR_SECRET?.trim();
+  if (secret) {
+    return secret;
   }
-  const sharedInternal = process.env.JUNIOR_INTERNAL_RESUME_SECRET?.trim();
-  if (sharedInternal) {
-    return sharedInternal;
-  }
-  throw new Error(
-    "Cannot determine sandbox egress secret (set JUNIOR_SANDBOX_EGRESS_SECRET or JUNIOR_INTERNAL_RESUME_SECRET)"
-  );
+  throw new Error("Cannot determine sandbox egress secret (set JUNIOR_SECRET)");
 }
 function base64Url(input) {
   return Buffer.from(input, "utf8").toString("base64url");
@@ -9167,7 +9637,7 @@ function fromBase64Url(input) {
   return Buffer.from(input, "base64url").toString("utf8");
 }
 function signPayload(payload) {
-  return createHmac("sha256", getSandboxEgressSecret()).update(payload).digest("base64url");
+  return createHmac("sha256", getSandboxEgressSecret()).update(`${SANDBOX_EGRESS_HMAC_CONTEXT}:${payload}`).digest("base64url");
 }
 function timingSafeMatch(expected, actual) {
   const expectedBuffer = Buffer.from(expected);
@@ -11207,319 +11677,123 @@ var AuthorizationPauseError = class extends Error {
     this.kind = kind;
     this.provider = provider;
   }
-};
-
-// src/chat/runtime/report-progress.ts
-function buildReportedProgressStatus(input) {
-  if (!input || typeof input !== "object") {
-    return void 0;
-  }
-  const message = input.message;
-  if (typeof message !== "string") {
-    return void 0;
-  }
-  const text = message.trim();
-  if (!text) {
-    return void 0;
-  }
-  return { text };
-}
-
-// src/chat/tools/execution/build-sandbox-input.ts
-function buildSandboxInput(toolName, params) {
-  const optionalNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
-  if (toolName === "bash") {
-    return {
-      command: String(params.command ?? ""),
-      ...optionalNumber(params.timeoutMs) ? { timeoutMs: optionalNumber(params.timeoutMs) } : {}
-    };
-  }
-  if (toolName === "readFile") {
-    return {
-      path: String(params.path ?? ""),
-      ...optionalNumber(params.offset) ? { offset: optionalNumber(params.offset) } : {},
-      ...optionalNumber(params.limit) ? { limit: optionalNumber(params.limit) } : {}
-    };
-  }
-  if (toolName === "editFile") {
-    return {
-      path: String(params.path ?? ""),
-      edits: Array.isArray(params.edits) ? params.edits : []
-    };
-  }
-  if (toolName === "grep") {
-    return {
-      pattern: String(params.pattern ?? ""),
-      ...typeof params.path === "string" ? { path: params.path } : {},
-      ...typeof params.glob === "string" ? { glob: params.glob } : {},
-      ...typeof params.ignoreCase === "boolean" ? { ignoreCase: params.ignoreCase } : {},
-      ...typeof params.literal === "boolean" ? { literal: params.literal } : {},
-      ...optionalNumber(params.context) ? { context: optionalNumber(params.context) } : {},
-      ...optionalNumber(params.limit) ? { limit: optionalNumber(params.limit) } : {}
-    };
-  }
-  if (toolName === "findFiles") {
-    return {
-      pattern: String(params.pattern ?? ""),
-      ...typeof params.path === "string" ? { path: params.path } : {},
-      ...optionalNumber(params.limit) ? { limit: optionalNumber(params.limit) } : {}
-    };
-  }
-  if (toolName === "listDir") {
-    return {
-      ...typeof params.path === "string" ? { path: params.path } : {},
-      ...optionalNumber(params.limit) ? { limit: optionalNumber(params.limit) } : {}
-    };
-  }
-  if (toolName === "writeFile") {
-    return {
-      path: String(params.path ?? ""),
-      content: String(params.content ?? "")
-    };
-  }
-  return params;
-}
-
-// src/chat/tools/execution/normalize-result.ts
-function isStructuredToolExecutionResult(value) {
-  const content = value?.content;
-  return typeof value === "object" && value !== null && Array.isArray(content) && content.every((part) => {
-    if (!part || typeof part !== "object") {
-      return false;
-    }
-    const record = part;
-    if (record.type === "text") {
-      return typeof record.text === "string";
-    }
-    if (record.type === "image") {
-      return typeof record.data === "string" && typeof record.mimeType === "string";
-    }
-    return false;
-  }) && "details" in value;
-}
-function toToolContentText(value) {
-  if (typeof value === "string") return value;
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-}
-function normalizeToolResult(result, isSandboxResult) {
-  const unwrapped = isSandboxResult && result && typeof result === "object" && "result" in result ? result.result : result;
-  if (isStructuredToolExecutionResult(unwrapped)) {
-    return unwrapped;
-  }
-  return {
-    content: [{ type: "text", text: toToolContentText(unwrapped) }],
-    details: unwrapped
-  };
-}
-
-// src/chat/credentials/unlink-provider.ts
-async function unlinkProvider(userId, provider, userTokenStore) {
-  await Promise.all([
-    userTokenStore.delete(userId, provider),
-    deleteMcpStoredOAuthCredentials(userId, provider),
-    deleteMcpServerSessionId(userId, provider),
-    deleteMcpAuthSessionsForUserProvider(userId, provider)
-  ]);
-}
-
-// src/chat/state/turn-session-store.ts
-var AGENT_TURN_SESSION_PREFIX = "junior:agent_turn_session";
-var AGENT_TURN_SESSION_TTL_MS = 24 * 60 * 60 * 1e3;
-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 parseAgentTurnSessionCheckpoint(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  try {
-    const parsed = JSON.parse(value);
-    if (!isRecord(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;
-    }
-    return {
-      checkpointVersion,
-      conversationId,
-      sessionId,
-      sliceId,
-      state: status,
-      updatedAtMs,
-      ...cumulativeDurationMs !== void 0 ? { cumulativeDurationMs } : {},
-      ...cumulativeUsage ? { cumulativeUsage } : {},
-      piMessages: Array.isArray(parsed.piMessages) ? parsed.piMessages : [],
-      ...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 } : {}
-    };
-  } catch {
-    return void 0;
-  }
-}
-async function getAgentTurnSessionCheckpoint(conversationId, sessionId) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const value = await stateAdapter.get(
-    agentTurnSessionKey(conversationId, sessionId)
-  );
-  return parseAgentTurnSessionCheckpoint(value);
-}
-async function upsertAgentTurnSessionCheckpoint(args) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const existing = await getAgentTurnSessionCheckpoint(
-    args.conversationId,
-    args.sessionId
-  );
-  const checkpoint = {
-    checkpointVersion: (existing?.checkpointVersion ?? 0) + 1,
-    conversationId: args.conversationId,
-    sessionId: args.sessionId,
-    sliceId: args.sliceId,
-    state: args.state,
-    updatedAtMs: Date.now(),
-    piMessages: Array.isArray(args.piMessages) ? args.piMessages : [],
-    ...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 } : {}
-  };
-  const ttlMs = Math.max(1, args.ttlMs ?? AGENT_TURN_SESSION_TTL_MS);
-  await stateAdapter.set(
-    agentTurnSessionKey(args.conversationId, args.sessionId),
-    JSON.stringify(checkpoint),
-    ttlMs
-  );
-  return checkpoint;
-}
-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
-  });
-}
+};
 
-// src/chat/services/pending-auth.ts
-var AUTH_LINK_REUSE_WINDOW_MS = 10 * 60 * 1e3;
-function canReusePendingAuthLink(args) {
-  const { pendingAuth } = args;
-  if (!pendingAuth) {
-    return false;
+// src/chat/runtime/report-progress.ts
+function buildReportedProgressStatus(input) {
+  if (!input || typeof input !== "object") {
+    return void 0;
   }
-  return pendingAuth.kind === args.kind && pendingAuth.provider === args.provider && pendingAuth.requesterId === args.requesterId && pendingAuth.linkSentAtMs + AUTH_LINK_REUSE_WINDOW_MS > (args.nowMs ?? Date.now());
-}
-function getConversationPendingAuth(args) {
-  const pendingAuth = args.conversation.processing.pendingAuth;
-  if (!pendingAuth) {
+  const message = input.message;
+  if (typeof message !== "string") {
     return void 0;
   }
-  if (pendingAuth.kind !== args.kind || pendingAuth.provider !== args.provider || pendingAuth.requesterId !== args.requesterId) {
+  const text = message.trim();
+  if (!text) {
     return void 0;
   }
-  return pendingAuth;
+  return { text };
 }
-function clearPendingAuth(conversation, sessionId) {
-  if (!conversation.processing.pendingAuth) {
-    return;
+
+// src/chat/tools/execution/build-sandbox-input.ts
+function buildSandboxInput(toolName, params) {
+  const optionalNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+  if (toolName === "bash") {
+    return {
+      command: String(params.command ?? ""),
+      ...optionalNumber(params.timeoutMs) ? { timeoutMs: optionalNumber(params.timeoutMs) } : {}
+    };
   }
-  if (sessionId && conversation.processing.pendingAuth.sessionId !== sessionId) {
-    return;
+  if (toolName === "readFile") {
+    return {
+      path: String(params.path ?? ""),
+      ...optionalNumber(params.offset) ? { offset: optionalNumber(params.offset) } : {},
+      ...optionalNumber(params.limit) ? { limit: optionalNumber(params.limit) } : {}
+    };
   }
-  conversation.processing.pendingAuth = void 0;
-}
-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({
-      conversationId: args.conversationId,
-      sessionId: previousPendingAuth.sessionId,
-      errorMessage: "Superseded by a newer auth-blocked request in the same conversation."
-    });
+  if (toolName === "editFile") {
+    return {
+      path: String(params.path ?? ""),
+      edits: Array.isArray(params.edits) ? params.edits : []
+    };
+  }
+  if (toolName === "grep") {
+    return {
+      pattern: String(params.pattern ?? ""),
+      ...typeof params.path === "string" ? { path: params.path } : {},
+      ...typeof params.glob === "string" ? { glob: params.glob } : {},
+      ...typeof params.ignoreCase === "boolean" ? { ignoreCase: params.ignoreCase } : {},
+      ...typeof params.literal === "boolean" ? { literal: params.literal } : {},
+      ...optionalNumber(params.context) ? { context: optionalNumber(params.context) } : {},
+      ...optionalNumber(params.limit) ? { limit: optionalNumber(params.limit) } : {}
+    };
+  }
+  if (toolName === "findFiles") {
+    return {
+      pattern: String(params.pattern ?? ""),
+      ...typeof params.path === "string" ? { path: params.path } : {},
+      ...optionalNumber(params.limit) ? { limit: optionalNumber(params.limit) } : {}
+    };
+  }
+  if (toolName === "listDir") {
+    return {
+      ...typeof params.path === "string" ? { path: params.path } : {},
+      ...optionalNumber(params.limit) ? { limit: optionalNumber(params.limit) } : {}
+    };
+  }
+  if (toolName === "writeFile") {
+    return {
+      path: String(params.path ?? ""),
+      content: String(params.content ?? "")
+    };
   }
+  return params;
 }
-function isPendingAuthLatestRequest(conversation, pendingAuth) {
-  for (let index = conversation.messages.length - 1; index >= 0; index -= 1) {
-    const message = conversation.messages[index];
-    if (message?.role !== "user") {
-      continue;
+
+// src/chat/tools/execution/normalize-result.ts
+function isStructuredToolExecutionResult(value) {
+  const content = value?.content;
+  return typeof value === "object" && value !== null && Array.isArray(content) && content.every((part) => {
+    if (!part || typeof part !== "object") {
+      return false;
     }
-    return buildDeterministicTurnId(message.id) === pendingAuth.sessionId;
+    const record = part;
+    if (record.type === "text") {
+      return typeof record.text === "string";
+    }
+    if (record.type === "image") {
+      return typeof record.data === "string" && typeof record.mimeType === "string";
+    }
+    return false;
+  }) && "details" in value;
+}
+function toToolContentText(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
   }
-  return false;
+}
+function normalizeToolResult(result, isSandboxResult) {
+  const unwrapped = isSandboxResult && result && typeof result === "object" && "result" in result ? result.result : result;
+  if (isStructuredToolExecutionResult(unwrapped)) {
+    return unwrapped;
+  }
+  return {
+    content: [{ type: "text", text: toToolContentText(unwrapped) }],
+    details: unwrapped
+  };
+}
+
+// src/chat/credentials/unlink-provider.ts
+async function unlinkProvider(userId, provider, userTokenStore) {
+  await Promise.all([
+    userTokenStore.delete(userId, provider),
+    deleteMcpStoredOAuthCredentials(userId, provider),
+    deleteMcpServerSessionId(userId, provider),
+    deleteMcpAuthSessionsForUserProvider(userId, provider)
+  ]);
 }
 
 // src/chat/services/plugin-auth-orchestration.ts
@@ -12000,7 +12274,6 @@ function buildBriefPostCanvasReply(artifactStatePatch) {
 function buildTurnResult(input) {
   const {
     newMessages,
-    piMessages,
     userInput,
     replyFiles,
     artifactStatePatch,
@@ -12035,7 +12308,11 @@ function buildTurnResult(input) {
     hasFiles: replyFiles.length > 0
   });
   const sideEffectOnlySuccess = !primaryText && toolErrorCount === 0 && (reactionPerformed || channelPostPerformed || replyFiles.length > 0);
-  if (!primaryText && !sideEffectOnlySuccess) {
+  const lastAssistant = terminalAssistantMessages.at(-1);
+  const stopReason = typeof lastAssistant?.stopReason === "string" ? lastAssistant.stopReason : void 0;
+  const errorMessage = typeof lastAssistant?.errorMessage === "string" ? lastAssistant.errorMessage : void 0;
+  const isProviderError = stopReason === "error";
+  if (!primaryText && !sideEffectOnlySuccess && !isProviderError) {
     logWarn(
       "ai_model_response_empty",
       {
@@ -12054,11 +12331,15 @@ function buildTurnResult(input) {
       "Model returned empty text response"
     );
   }
-  const lastAssistant = terminalAssistantMessages.at(-1);
-  const stopReason = typeof lastAssistant?.stopReason === "string" ? lastAssistant.stopReason : void 0;
-  const errorMessage = typeof lastAssistant?.errorMessage === "string" ? lastAssistant.errorMessage : void 0;
   const usedPrimaryText = Boolean(primaryText);
-  const outcome = primaryText ? stopReason === "error" ? "provider_error" : "success" : sideEffectOnlySuccess ? "success" : "execution_failure";
+  let outcome;
+  if (isProviderError) {
+    outcome = "provider_error";
+  } else if (primaryText || sideEffectOnlySuccess) {
+    outcome = "success";
+  } else {
+    outcome = "execution_failure";
+  }
   const suppressReactionOnlyText = reactionPerformed && !channelPostPerformed && replyFiles.length === 0 && Boolean(primaryText) && isReactionOnlyIntent(userInput);
   const rawResponseText = suppressReactionOnlyText ? "" : primaryText;
   const responseText = canvasCreated && isVerbosePostCanvasReply(rawResponseText) ? buildBriefPostCanvasReply(artifactStatePatch) : rawResponseText;
@@ -12104,7 +12385,6 @@ function buildTurnResult(input) {
     text: resolvedText,
     files: replyFiles.length > 0 ? replyFiles : void 0,
     artifactStatePatch: Object.keys(artifactStatePatch).length > 0 ? artifactStatePatch : void 0,
-    piMessages,
     deliveryPlan,
     deliveryMode,
     sandboxId,
@@ -12113,6 +12393,27 @@ function buildTurnResult(input) {
   };
 }
 
+// src/chat/services/provider-retry.ts
+var RETRYABLE_PROVIDER_ERROR_PATTERN = /overloaded|provider.?returned.?error|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server.?error|internal.?error|network.?error|connection.?error|connection.?refused|connection.?lost|websocket.?closed|websocket.?error|other side closed|fetch failed|upstream.?connect|reset before headers|socket hang up|ended without|stream ended before message_stop|http2 request did not get a response|timed? out|timeout|terminated|retry delay/i;
+var NON_RETRYABLE_PROVIDER_ERROR_PATTERN = /invalid.?api.?key|authentication|authorization|permission|forbidden|context.?length|context.?window|content.?policy|validation|bad request|400|401|403/i;
+function isRetryableProviderError(message) {
+  if (message?.stopReason !== "error" || !message.errorMessage) {
+    return false;
+  }
+  if (NON_RETRYABLE_PROVIDER_ERROR_PATTERN.test(message.errorMessage)) {
+    return false;
+  }
+  return RETRYABLE_PROVIDER_ERROR_PATTERN.test(message.errorMessage);
+}
+function trimRetryableProviderErrorTail(messages) {
+  const trimmed = trimTrailingAssistantMessages(messages);
+  if (trimmed.length === messages.length) {
+    return void 0;
+  }
+  const tailRole = getPiMessageRole(trimmed.at(-1));
+  return tailRole === "user" || tailRole === "toolResult" ? trimmed : void 0;
+}
+
 // src/chat/services/turn-thinking-level.ts
 import { z } from "zod";
 var CLASSIFIER_CONFIDENCE_THRESHOLD = 0.75;
@@ -12516,7 +12817,7 @@ async function persistAuthPauseCheckpoint(args) {
     const piMessages = trimTrailingAssistantMessages(
       args.messages.length > 0 ? args.messages : latestCheckpoint?.piMessages ?? []
     );
-    await upsertAgentTurnSessionCheckpoint({
+    return await upsertAgentTurnSessionCheckpoint({
       conversationId: args.conversationId,
       cumulativeDurationMs: addDurationMs(
         latestCheckpoint?.cumulativeDurationMs,
@@ -12547,7 +12848,7 @@ async function persistAuthPauseCheckpoint(args) {
       "Failed to persist auth checkpoint before retry"
     );
   }
-  return nextSliceId;
+  return void 0;
 }
 async function persistTimeoutCheckpoint(args) {
   const nextSliceId = args.currentSliceId + 1;
@@ -12686,6 +12987,10 @@ function createMcpAuthOrchestration(deps, abortAgent) {
 }
 
 // src/chat/respond.ts
+var PROVIDER_RETRY_DELAYS_MS = [1e3, 2e3];
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 var startupDiscoveryLogged = false;
 var MAX_ROUTER_ATTACHMENT_PREVIEW_CHARS = 2e3;
 function buildOmittedImageAttachmentNotice(count) {
@@ -12787,69 +13092,6 @@ function buildUserTurnInput(args) {
   }
   return { routerBlocks, userContentParts };
 }
-function refreshCheckpointTurnContext(messages, turnContextPrompt) {
-  const marker = getTurnContextMarker(turnContextPrompt);
-  for (let index = 0; index < messages.length; index += 1) {
-    const content = getUserMessageContent(messages[index]);
-    if (!content) {
-      continue;
-    }
-    const contextIndex = content.findIndex(
-      (part) => isTurnContextPart(part, marker)
-    );
-    if (contextIndex < 0) {
-      continue;
-    }
-    const updatedMessages = [...messages];
-    const updatedContent = [...content];
-    updatedContent[contextIndex] = {
-      ...updatedContent[contextIndex],
-      text: turnContextPrompt
-    };
-    updatedMessages[index] = {
-      ...messages[index],
-      content: updatedContent
-    };
-    return updatedMessages;
-  }
-  return [
-    ...messages,
-    {
-      role: "user",
-      content: [{ type: "text", text: turnContextPrompt }],
-      timestamp: Date.now()
-    }
-  ];
-}
-function stripTurnContextFromMessages(messages, turnContextPrompt) {
-  const marker = getTurnContextMarker(turnContextPrompt);
-  return messages.flatMap((message) => {
-    const content = getUserMessageContent(message);
-    if (!content) {
-      return [message];
-    }
-    const strippedContent = content.filter(
-      (part) => !isTurnContextPart(part, marker)
-    );
-    if (strippedContent.length === content.length) {
-      return [message];
-    }
-    if (strippedContent.length === 0) {
-      return [];
-    }
-    return [{ ...message, content: strippedContent }];
-  });
-}
-function getTurnContextMarker(turnContextPrompt) {
-  return turnContextPrompt.split("\n", 1)[0];
-}
-function getUserMessageContent(message) {
-  const record = message;
-  return record.role === "user" && Array.isArray(record.content) ? record.content : void 0;
-}
-function isTurnContextPart(part, marker) {
-  return part !== null && typeof part === "object" && part.type === "text" && typeof part.text === "string" && part.text.startsWith(marker);
-}
 async function generateAssistantReply(messageText, context = {}) {
   const replyStartedAtMs = Date.now();
   let timeoutResumeConversationId;
@@ -13046,11 +13288,7 @@ async function generateAssistantReply(messageText, context = {}) {
     const promptConversationContext = context.piMessages && context.piMessages.length > 0 ? void 0 : context.conversationContext;
     const userTurnText = buildUserTurnText(
       userInput,
-      promptConversationContext,
-      {
-        sessionContext: { conversationId: sessionConversationId },
-        turnContext: { traceId: getActiveTraceId() }
-      }
+      promptConversationContext
     );
     const { routerBlocks, userContentParts } = buildUserTurnInput({
       omittedImageAttachmentCount: context.omittedImageAttachmentCount ?? 0,
@@ -13235,11 +13473,8 @@ async function generateAssistantReply(messageText, context = {}) {
       activeMcpCatalogs,
       toolGuidance,
       runtime: {
-        channelId: toolChannelId,
-        fastModelId: botConfig.fastModelId,
-        modelId: botConfig.modelId,
-        slackCapabilities: channelCapabilities,
-        thinkingLevel: thinkingSelection.thinkingLevel
+        conversationId: spanContext.conversationId,
+        traceId: getActiveTraceId()
       },
       invocation: skillInvocation,
       requester: context.requester,
@@ -13362,7 +13597,7 @@ async function generateAssistantReply(messageText, context = {}) {
     beforeMessageCount = agent.state.messages.length;
     try {
       if (resumedFromCheckpoint) {
-        agent.state.messages = refreshCheckpointTurnContext(
+        agent.state.messages = refreshRuntimeTurnContext(
           existingCheckpoint.piMessages,
           turnContextPrompt
         );
@@ -13387,67 +13622,96 @@ async function generateAssistantReply(messageText, context = {}) {
               freshPromptMessage
             ]);
           }
-          const promptPromise = resumedFromCheckpoint ? agent.continue() : agent.prompt(freshPromptMessage);
-          let timeoutId;
-          const timeoutPromise = new Promise((_, reject) => {
-            timeoutId = setTimeout(() => {
-              timedOut = true;
-              agent.abort();
-              reject(
-                new Error(
-                  `Agent turn timed out after ${botConfig.turnTimeoutMs}ms`
-                )
-              );
-            }, botConfig.turnTimeoutMs);
-          });
-          try {
-            promptResult = await Promise.race([promptPromise, timeoutPromise]);
-          } catch (error) {
-            if (timedOut) {
-              logWarn(
-                "agent_turn_timeout",
-                {},
-                {
-                  "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
-                  "gen_ai.operation.name": "invoke_agent",
-                  "gen_ai.request.model": botConfig.modelId,
-                  ...thinkingSelection ? {
-                    "app.ai.reasoning_effort": thinkingSelection.thinkingLevel
-                  } : {},
-                  "app.ai.turn_timeout_ms": botConfig.turnTimeoutMs
-                },
-                "Agent turn timed out and was aborted"
-              );
-              await promptPromise.catch(() => {
-              });
-              timeoutResumeMessages = [...agent.state.messages];
+          const runAgentStep = async (run2) => {
+            let timeoutId;
+            const timeoutPromise = new Promise((_, reject) => {
+              timeoutId = setTimeout(() => {
+                timedOut = true;
+                agent.abort();
+                reject(
+                  new Error(
+                    `Agent turn timed out after ${botConfig.turnTimeoutMs}ms`
+                  )
+                );
+              }, botConfig.turnTimeoutMs);
+            });
+            try {
+              return await Promise.race([run2, timeoutPromise]);
+            } catch (error) {
+              if (timedOut) {
+                logWarn(
+                  "agent_turn_timeout",
+                  {},
+                  {
+                    "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
+                    "gen_ai.operation.name": "invoke_agent",
+                    "gen_ai.request.model": botConfig.modelId,
+                    ...thinkingSelection ? {
+                      "app.ai.reasoning_effort": thinkingSelection.thinkingLevel
+                    } : {},
+                    "app.ai.turn_timeout_ms": botConfig.turnTimeoutMs
+                  },
+                  "Agent turn timed out and was aborted"
+                );
+                await run2.catch(() => {
+                });
+                timeoutResumeMessages = [...agent.state.messages];
+              }
+              if (getPendingAuthPause()) {
+                timeoutResumeMessages = [...agent.state.messages];
+                throw getPendingAuthPause();
+              }
+              throw error;
+            } finally {
+              if (timeoutId) {
+                clearTimeout(timeoutId);
+              }
             }
+          };
+          let run = resumedFromCheckpoint ? 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 usageSummary = extractGenAiUsageSummary(
+              promptResult,
+              agent.state,
+              ...outputMessages
+            );
+            const currentUsage = hasAgentTurnUsage(usageSummary) ? usageSummary : void 0;
+            turnUsage = addAgentTurnUsage(retryUsage, currentUsage);
+            setSpanAttributes({
+              ...outputMessagesAttribute ? { "gen_ai.output.messages": outputMessagesAttribute } : {},
+              ...extractGenAiUsageAttributes(usageSummary)
+            });
             if (getPendingAuthPause()) {
               timeoutResumeMessages = [...agent.state.messages];
               throw getPendingAuthPause();
             }
-            throw error;
-          } finally {
-            if (timeoutId) {
-              clearTimeout(timeoutId);
+            const lastAssistant = outputMessages.at(-1);
+            const retryDelayMs = PROVIDER_RETRY_DELAYS_MS[attempt];
+            if (retryDelayMs === void 0 || !isRetryableProviderError(lastAssistant)) {
+              break;
             }
-          }
-          newMessages = agent.state.messages.slice(beforeMessageCount);
-          const outputMessages = newMessages.filter(isAssistantMessage);
-          const outputMessagesAttribute = serializeGenAiAttribute(outputMessages);
-          const usageSummary = extractGenAiUsageSummary(
-            promptResult,
-            agent.state,
-            ...outputMessages
-          );
-          turnUsage = hasAgentTurnUsage(usageSummary) ? usageSummary : void 0;
-          setSpanAttributes({
-            ...outputMessagesAttribute ? { "gen_ai.output.messages": outputMessagesAttribute } : {},
-            ...extractGenAiUsageAttributes(usageSummary)
-          });
-          if (getPendingAuthPause()) {
-            timeoutResumeMessages = [...agent.state.messages];
-            throw getPendingAuthPause();
+            retryUsage = turnUsage;
+            const retryMessages = trimRetryableProviderErrorTail(
+              agent.state.messages
+            );
+            if (!retryMessages) {
+              break;
+            }
+            agent.state.messages = retryMessages;
+            await persistSafeBoundary(retryMessages);
+            logWarn(
+              "agent_turn_provider_retry",
+              spanContext,
+              {},
+              "Retrying transient provider failure"
+            );
+            await sleep3(retryDelayMs);
+            run = agent.continue();
           }
         },
         {
@@ -13475,10 +13739,6 @@ async function generateAssistantReply(messageText, context = {}) {
     }
     return buildTurnResult({
       newMessages,
-      piMessages: stripTurnContextFromMessages(
-        agent.state.messages,
-        turnContextPrompt
-      ),
       userInput,
       replyFiles,
       artifactStatePatch,
@@ -13528,7 +13788,7 @@ async function generateAssistantReply(messageText, context = {}) {
           beforeMessageCount
         );
       }
-      const nextSliceId = await persistAuthPauseCheckpoint({
+      const checkpoint = await persistAuthPauseCheckpoint({
         conversationId: timeoutResumeConversationId,
         sessionId: timeoutResumeSessionId,
         currentSliceId: timeoutResumeSliceId,
@@ -13539,21 +13799,23 @@ async function generateAssistantReply(messageText, context = {}) {
         errorMessage: error.message,
         logContext: checkpointLogContext
       });
-      throw new RetryableTurnError(
-        error.kind === "plugin" ? "plugin_auth_resume" : "mcp_auth_resume",
-        `conversation=${timeoutResumeConversationId} session=${timeoutResumeSessionId} slice=${nextSliceId}`,
-        {
-          authDisposition: error.disposition,
-          authDurationMs: Date.now() - replyStartedAtMs,
-          authKind: error.kind,
-          authProvider: error.provider,
-          authThinkingLevel: thinkingSelection?.thinkingLevel,
-          authUsage: turnUsage,
-          conversationId: timeoutResumeConversationId,
-          sessionId: timeoutResumeSessionId,
-          sliceId: nextSliceId
-        }
-      );
+      if (checkpoint) {
+        throw new RetryableTurnError(
+          error.kind === "plugin" ? "plugin_auth_resume" : "mcp_auth_resume",
+          `conversation=${timeoutResumeConversationId} session=${timeoutResumeSessionId} slice=${checkpoint.sliceId}`,
+          {
+            authDisposition: error.disposition,
+            authDurationMs: Date.now() - replyStartedAtMs,
+            authKind: error.kind,
+            authProvider: error.provider,
+            authThinkingLevel: thinkingSelection?.thinkingLevel,
+            authUsage: turnUsage,
+            conversationId: timeoutResumeConversationId,
+            sessionId: timeoutResumeSessionId,
+            sliceId: checkpoint.sliceId
+          }
+        );
+      }
     }
     if (isRetryableTurnError(error)) {
       throw error;
@@ -14769,16 +15031,10 @@ function createResumeReplyContext(args, statusSession) {
   };
 }
 async function resumeSlackTurn(args) {
-  if (!args.replyContext?.requester?.userId) {
-    throw new Error("Resumed turn requires replyContext.requester.userId");
-  }
   const stateAdapter = getStateAdapter();
   await stateAdapter.connect();
   const lockKey = args.lockKey ?? getDefaultLockKey(args.channelId, args.threadTs);
-  const lock = await stateAdapter.acquireLock(
-    lockKey,
-    botConfig.turnTimeoutMs + 6e4
-  );
+  const lock = await stateAdapter.acquireLock(lockKey, ACTIVE_LOCK_TTL_MS);
   if (!lock) {
     throw new ResumeTurnBusyError(lockKey);
   }
@@ -14790,31 +15046,44 @@ async function resumeSlackTurn(args) {
   let deferredPauseKind;
   let deferredPauseHandler;
   let deferredFailureHandler;
+  let finalReplyDelivered = false;
+  let postDeliveryCommitError;
+  let runArgs = args;
   try {
-    if (args.messageTs) {
+    const preparedArgs = await args.beforeStart?.();
+    if (preparedArgs === false) {
+      return;
+    }
+    if (preparedArgs) {
+      runArgs = { ...args, ...preparedArgs };
+    }
+    if (!runArgs.replyContext?.requester?.userId) {
+      throw new Error("Resumed turn requires replyContext.requester.userId");
+    }
+    if (runArgs.messageTs) {
       processingReaction = await startSlackProcessingReactionForMessage({
-        channelId: args.channelId,
-        timestamp: args.messageTs,
+        channelId: runArgs.channelId,
+        timestamp: runArgs.messageTs,
         logException,
-        logContext: { ...getResumeLogContext(args, lockKey) }
+        logContext: { ...getResumeLogContext(runArgs, lockKey) }
       });
     }
-    if (args.initialText) {
+    if (runArgs.initialText) {
       await postSlackMessageBestEffort(
-        args.channelId,
-        args.threadTs,
-        args.initialText
+        runArgs.channelId,
+        runArgs.threadTs,
+        runArgs.initialText
       );
     }
     status.start();
-    const generateReply = args.generateReply ?? generateAssistantReply;
-    const replyContext = createResumeReplyContext(args, status);
+    const generateReply = runArgs.generateReply ?? generateAssistantReply;
+    const replyContext = createResumeReplyContext(runArgs, status);
     const priorCheckpoint = replyContext.correlation?.conversationId && replyContext.correlation?.turnId ? await getAgentTurnSessionCheckpoint(
       replyContext.correlation.conversationId,
       replyContext.correlation.turnId
     ) : void 0;
-    const replyPromise = generateReply(args.messageText, replyContext);
-    const replyTimeoutMs = resolveReplyTimeoutMs(args.replyTimeoutMs);
+    const replyPromise = generateReply(runArgs.messageText, replyContext);
+    const replyTimeoutMs = resolveReplyTimeoutMs(runArgs.replyTimeoutMs);
     let reply = typeof replyTimeoutMs === "number" ? await Promise.race([
       replyPromise,
       new Promise(
@@ -14831,11 +15100,11 @@ async function resumeSlackTurn(args) {
     reply = finalizeFailedTurnReply({
       reply,
       logException,
-      context: getResumeLogContext(args, lockKey)
+      context: getResumeLogContext(runArgs, lockKey)
     });
     await status.stop();
     const footer = buildSlackReplyFooter({
-      conversationId: args.replyContext?.correlation?.conversationId ?? lockKey,
+      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,
       thinkingLevel: reply.diagnostics.thinkingLevel,
       usage: addAgentTurnUsage(
@@ -14844,18 +15113,32 @@ async function resumeSlackTurn(args) {
       ) ?? reply.diagnostics.usage
     });
     await postSlackApiReplyPosts({
-      channelId: args.channelId,
-      threadTs: args.threadTs,
+      channelId: runArgs.channelId,
+      threadTs: runArgs.threadTs,
       posts: planSlackReplyPosts({ reply }),
       fileUploadFailureMode: "best_effort",
       footer
     });
-    await args.onSuccess?.(reply);
+    finalReplyDelivered = true;
+    await runArgs.onSuccess?.(reply);
   } catch (error) {
     await status.stop();
-    const onAuthPause = args.onAuthPause;
-    const onTimeoutPause = args.onTimeoutPause;
-    if ((isRetryableTurnError(error, "mcp_auth_resume") || isRetryableTurnError(error, "plugin_auth_resume")) && onAuthPause) {
+    const onAuthPause = runArgs.onAuthPause;
+    const onTimeoutPause = runArgs.onTimeoutPause;
+    if (finalReplyDelivered) {
+      postDeliveryCommitError = error;
+      try {
+        await runArgs.onPostDeliveryCommitFailure?.(error);
+      } catch (terminalizeError) {
+        logException(
+          terminalizeError,
+          "slack_resume_post_delivery_terminalize_failed",
+          getResumeLogContext(runArgs, lockKey),
+          {},
+          "Failed to terminalize resumed turn after post-delivery commit failure"
+        );
+      }
+    } else if ((isRetryableTurnError(error, "mcp_auth_resume") || isRetryableTurnError(error, "plugin_auth_resume")) && onAuthPause) {
       deferredPauseKind = "auth";
       deferredPauseHandler = async () => {
         await onAuthPause(error);
@@ -14872,7 +15155,7 @@ async function resumeSlackTurn(args) {
           error,
           eventName: "slack_resume_turn_failed",
           lockKey,
-          resumeArgs: args
+          resumeArgs: runArgs
         });
       };
     }
@@ -14880,20 +15163,30 @@ async function resumeSlackTurn(args) {
     await processingReaction?.stop();
     await stateAdapter.releaseLock(lock);
   }
+  if (postDeliveryCommitError) {
+    logException(
+      postDeliveryCommitError,
+      "slack_resume_success_handler_failed",
+      getResumeLogContext(runArgs, lockKey),
+      {},
+      "Failed to persist resumed turn state after final reply delivery"
+    );
+    throw postDeliveryCommitError;
+  }
   if (deferredPauseHandler) {
     try {
       await deferredPauseHandler();
       if (deferredPauseKind === "auth") {
         await postSlackMessageBestEffort(
-          args.channelId,
-          args.threadTs,
+          runArgs.channelId,
+          runArgs.threadTs,
           buildAuthPauseResponse()
         );
       }
       if (deferredPauseKind === "timeout") {
         await postTurnContinuationNoticeBestEffort({
           lockKey,
-          resumeArgs: args
+          resumeArgs: runArgs
         });
       }
       return;
@@ -14903,7 +15196,7 @@ async function resumeSlackTurn(args) {
         error: pauseError,
         eventName: "slack_resume_pause_handler_failed",
         lockKey,
-        resumeArgs: args
+        resumeArgs: runArgs
       });
       return;
     }
@@ -14926,6 +15219,8 @@ async function resumeAuthorizedRequest(args) {
     onFailure: args.onFailure,
     onAuthPause: args.onAuthPause,
     onTimeoutPause: args.onTimeoutPause,
+    onPostDeliveryCommitFailure: args.onPostDeliveryCommitFailure,
+    beforeStart: args.beforeStart,
     replyTimeoutMs: args.replyTimeoutMs
   });
 }
@@ -14940,7 +15235,7 @@ function completeAuthPauseTurn(args) {
       skippedReason: void 0
     }
   );
-  markTurnCompleted({
+  markTurnClosed({
     conversation: args.conversation,
     nowMs: Date.now(),
     sessionId: args.sessionId,
@@ -14960,6 +15255,7 @@ async function persistAuthPauseTurnState(args) {
 // src/chat/services/timeout-resume.ts
 import { createHmac as createHmac2, timingSafeEqual as timingSafeEqual2 } from "crypto";
 var TURN_TIMEOUT_RESUME_PATH = "/api/internal/turn-resume";
+var TURN_TIMEOUT_RESUME_HMAC_CONTEXT = "junior.turn_timeout_resume.v1";
 var TURN_TIMEOUT_RESUME_SIGNATURE_VERSION = "v1";
 var TURN_TIMEOUT_RESUME_MAX_SKEW_MS = 5 * 60 * 1e3;
 var TURN_TIMEOUT_RESUME_TIMESTAMP_HEADER = "x-junior-resume-timestamp";
@@ -14983,14 +15279,10 @@ async function getAwaitingTurnContinuationRequest(args) {
   };
 }
 function getTurnTimeoutResumeSecret() {
-  const explicit = process.env.JUNIOR_INTERNAL_RESUME_SECRET?.trim();
-  if (explicit) {
-    return explicit;
-  }
-  return getSlackSigningSecret();
+  return process.env.JUNIOR_SECRET?.trim() || void 0;
 }
 function buildSignedPayload(timestamp, body) {
-  return `${timestamp}:${body}`;
+  return `${TURN_TIMEOUT_RESUME_HMAC_CONTEXT}:${timestamp}:${body}`;
 }
 function signTurnTimeoutResumeBody(secret, timestamp, body) {
   const digest = createHmac2("sha256", secret).update(buildSignedPayload(timestamp, body)).digest("hex");
@@ -15028,7 +15320,7 @@ async function scheduleTurnTimeoutResume(request) {
   const secret = getTurnTimeoutResumeSecret();
   if (!secret) {
     throw new Error(
-      "Cannot determine timeout resume secret (set JUNIOR_INTERNAL_RESUME_SECRET or SLACK_SIGNING_SECRET)"
+      "Cannot determine timeout resume secret (set JUNIOR_SECRET)"
     );
   }
   const body = JSON.stringify(request);
@@ -15126,57 +15418,43 @@ function htmlResponse(kind) {
   const page = CALLBACK_PAGES[kind];
   return htmlCallbackResponse(page.title, page.message, page.status);
 }
-async function buildResumeConversationContext(channelId, threadTs, sessionId) {
-  const threadId = `slack:${channelId}:${threadTs}`;
-  const conversation = coerceThreadConversationState(
-    await getPersistedThreadState(threadId)
-  );
-  const userMessageId = getTurnUserMessageId(conversation, sessionId);
-  return buildConversationContext(conversation, {
-    excludeMessageId: userMessageId
-  });
-}
 async function persistCompletedReplyState(channelId, threadTs, sessionId, reply) {
   const threadId = `slack:${channelId}:${threadTs}`;
   const currentState = await getPersistedThreadState(threadId);
   const conversation = coerceThreadConversationState(currentState);
   const artifacts = coerceThreadArtifactsState(currentState);
-  const nextArtifacts = reply.artifactStatePatch ? mergeArtifactsState(artifacts, reply.artifactStatePatch) : void 0;
-  const userMessageId = getTurnUserMessageId(conversation, sessionId);
-  clearPendingAuth(conversation, sessionId);
-  markConversationMessage(conversation, userMessageId, {
-    replied: true,
-    skippedReason: void 0
-  });
-  upsertConversationMessage(conversation, {
-    id: generateConversationId("assistant"),
-    role: "assistant",
-    text: normalizeConversationText(reply.text) || "[empty response]",
-    createdAtMs: Date.now(),
-    author: {
-      userName: botConfig.userName,
-      isBot: true
-    },
-    meta: {
-      replied: true
-    }
-  });
-  if (reply.piMessages) {
-    conversation.piMessages = reply.piMessages;
-  }
-  markTurnCompleted({
+  const userMessage = getTurnUserMessage(conversation, sessionId);
+  const statePatch = buildDeliveredTurnStatePatch({
+    artifacts,
     conversation,
-    nowMs: Date.now(),
+    reply,
     sessionId,
-    updateConversationStats
+    userMessageId: userMessage?.id
   });
   await persistThreadStateById(threadId, {
-    artifacts: nextArtifacts,
-    conversation,
-    sandboxId: reply.sandboxId,
-    sandboxDependencyProfileHash: reply.sandboxDependencyProfileHash
+    ...statePatch
   });
 }
+async function failCheckpointBestEffort(args) {
+  try {
+    await failAgentTurnSessionCheckpoint({
+      conversationId: args.conversationId,
+      sessionId: args.sessionId,
+      errorMessage: args.errorMessage
+    });
+  } catch (error) {
+    logException(
+      error,
+      "mcp_oauth_callback_checkpoint_fail_persist_failed",
+      {},
+      {
+        "app.ai.conversation_id": args.conversationId,
+        "app.ai.session_id": args.sessionId
+      },
+      "Failed to mark MCP OAuth-resumed turn checkpoint failed"
+    );
+  }
+}
 async function persistFailedReplyState(channelId, threadTs, sessionId) {
   const threadId = `slack:${channelId}:${threadTs}`;
   const currentState = await getPersistedThreadState(threadId);
@@ -15190,6 +15468,11 @@ async function persistFailedReplyState(channelId, threadTs, sessionId) {
     markConversationMessage,
     updateConversationStats
   });
+  await failCheckpointBestEffort({
+    conversationId: threadId,
+    sessionId,
+    errorMessage: "OAuth-resumed MCP turn failed"
+  });
   await persistThreadStateById(threadId, {
     conversation
   });
@@ -15202,7 +15485,6 @@ async function resumeAuthorizedMcpTurn(args) {
   const threadId = `slack:${authSession.channelId}:${authSession.threadTs}`;
   const currentState = await getPersistedThreadState(threadId);
   const conversation = coerceThreadConversationState(currentState);
-  const artifacts = coerceThreadArtifactsState(currentState);
   const pendingAuth = getConversationPendingAuth({
     conversation,
     kind: "mcp",
@@ -15228,132 +15510,174 @@ async function resumeAuthorizedMcpTurn(args) {
   if (!userMessage) {
     return;
   }
-  const channelConfiguration = getChannelConfigurationServiceById(
-    authSession.channelId
-  );
-  const conversationContext = await buildResumeConversationContext(
-    authSession.channelId,
-    authSession.threadTs,
-    resolvedSessionId
-  );
   await resumeAuthorizedRequest({
     messageText: userMessage.text,
     channelId: authSession.channelId,
     threadTs: authSession.threadTs,
     messageTs: getTurnUserSlackMessageTs(userMessage),
-    lockKey: authSession.conversationId,
+    lockKey: threadId,
     connectedText: "",
-    replyContext: {
-      requester: {
-        userId: authSession.userId,
-        userName: userMessage?.author?.userName,
-        fullName: userMessage?.author?.fullName
-      },
-      correlation: {
-        conversationId: authSession.conversationId,
-        turnId: resolvedSessionId,
-        channelId: authSession.channelId,
-        threadTs: authSession.threadTs,
+    beforeStart: async () => {
+      const lockedState = await getPersistedThreadState(threadId);
+      const lockedConversation = coerceThreadConversationState(lockedState);
+      const lockedArtifacts = coerceThreadArtifactsState(lockedState);
+      const lockedPendingAuth = getConversationPendingAuth({
+        conversation: lockedConversation,
+        kind: "mcp",
+        provider,
         requesterId: authSession.userId
-      },
-      toolChannelId: authSession.toolChannelId ?? artifacts.assistantContextChannelId ?? authSession.channelId,
-      conversationContext,
-      artifactState: artifacts,
-      piMessages: conversation.piMessages,
-      configuration: authSession.configuration,
-      pendingAuth,
-      channelConfiguration,
-      sandbox: getPersistedSandboxState(currentState),
-      onAuthPending: async (nextPendingAuth) => {
-        await applyPendingAuthUpdate({
-          conversation,
-          conversationId: authSession.conversationId,
-          nextPendingAuth
-        });
-        await persistThreadStateById(threadId, { conversation });
-      },
-      ...getTurnUserReplyAttachmentContext(userMessage)
-    },
-    onSuccess: async (reply) => {
-      try {
-        await persistCompletedReplyState(
-          authSession.channelId,
-          authSession.threadTs,
-          resolvedSessionId,
-          reply
-        );
-      } catch (persistError) {
-        logException(
-          persistError,
-          "mcp_oauth_callback_resume_persist_failed",
-          {},
-          { "app.credential.provider": provider },
-          "Failed to persist resumed MCP turn state"
-        );
+      });
+      const lockedSessionId = lockedPendingAuth?.sessionId ?? authSession.sessionId;
+      if (lockedSessionId !== resolvedSessionId) {
+        return false;
       }
-    },
-    onFailure: async () => {
-      try {
-        await persistFailedReplyState(
-          authSession.channelId,
-          authSession.threadTs,
-          resolvedSessionId
-        );
-      } catch (persistError) {
-        logException(
-          persistError,
-          "mcp_oauth_callback_resume_failure_persist_failed",
-          {},
-          { "app.credential.provider": provider },
-          "Failed to persist failed MCP resume state"
-        );
+      if (lockedPendingAuth) {
+        if (!isPendingAuthLatestRequest(lockedConversation, lockedPendingAuth)) {
+          clearPendingAuth(lockedConversation, lockedPendingAuth.sessionId);
+          await persistThreadStateById(threadId, {
+            conversation: lockedConversation
+          });
+          await supersedeAgentTurnSessionCheckpoint({
+            conversationId: authSession.conversationId,
+            sessionId: lockedPendingAuth.sessionId,
+            errorMessage: "Auth completed after a newer thread message superseded this blocked request."
+          });
+          return false;
+        }
+      } else if (lockedConversation.processing.activeTurnId !== authSession.sessionId) {
+        return false;
       }
-    },
-    onAuthPause: async (error) => {
-      await persistAuthPauseTurnState({
-        sessionId: resolvedSessionId,
-        threadStateId: `slack:${authSession.channelId}:${authSession.threadTs}`
-      });
-      logWarn(
-        "mcp_oauth_callback_resume_reparked_for_auth",
-        {},
-        {
-          "app.credential.provider": provider,
-          ...isRetryableTurnError(error) ? { "app.ai.retryable_reason": error.reason } : {}
-        },
-        "Resumed MCP turn requested another authorization flow"
+      const lockedUserMessage = getTurnUserMessage(
+        lockedConversation,
+        lockedSessionId
       );
-    },
-    onTimeoutPause: async (error) => {
-      if (!isRetryableTurnError(error, "turn_timeout_resume")) {
-        throw error;
-      }
-      const checkpointVersion = error.metadata?.checkpointVersion;
-      const nextSliceId = error.metadata?.sliceId;
-      if (typeof checkpointVersion !== "number") {
-        throw new Error(
-          "Timed-out MCP resume did not include a checkpoint version"
-        );
+      if (!lockedUserMessage) {
+        return false;
       }
-      if (!canScheduleTurnTimeoutResume(nextSliceId)) {
-        logWarn(
-          "mcp_oauth_callback_resume_slice_limit_reached",
-          {},
-          {
-            "app.credential.provider": provider,
-            ...typeof nextSliceId === "number" ? { "app.ai.resume_slice_id": nextSliceId } : {}
+      const lockedConversationContext = buildConversationContext(
+        lockedConversation,
+        {
+          excludeMessageId: lockedUserMessage.id
+        }
+      );
+      const lockedChannelConfiguration = getChannelConfigurationServiceById(
+        authSession.channelId
+      );
+      return {
+        messageText: lockedUserMessage.text,
+        messageTs: getTurnUserSlackMessageTs(lockedUserMessage),
+        replyContext: {
+          requester: {
+            userId: authSession.userId,
+            userName: lockedUserMessage.author?.userName,
+            fullName: lockedUserMessage.author?.fullName
           },
-          "Skipped automatic timeout resume because the turn exceeded the slice limit"
-        );
-        throw new Error(
-          "Timed-out turn exceeded the automatic resume slice limit"
-        );
-      }
-      await scheduleTurnTimeoutResume({
-        conversationId: authSession.conversationId,
-        sessionId: resolvedSessionId,
-        expectedCheckpointVersion: checkpointVersion
-      });
+          correlation: {
+            conversationId: authSession.conversationId,
+            turnId: lockedSessionId,
+            channelId: authSession.channelId,
+            threadTs: authSession.threadTs,
+            requesterId: authSession.userId
+          },
+          toolChannelId: authSession.toolChannelId ?? lockedArtifacts.assistantContextChannelId ?? authSession.channelId,
+          conversationContext: lockedConversationContext,
+          artifactState: lockedArtifacts,
+          piMessages: lockedConversation.piMessages,
+          configuration: authSession.configuration,
+          pendingAuth: lockedPendingAuth,
+          channelConfiguration: lockedChannelConfiguration,
+          sandbox: getPersistedSandboxState(lockedState),
+          onAuthPending: async (nextPendingAuth) => {
+            await applyPendingAuthUpdate({
+              conversation: lockedConversation,
+              conversationId: authSession.conversationId,
+              nextPendingAuth
+            });
+            await persistThreadStateById(threadId, {
+              conversation: lockedConversation
+            });
+          },
+          ...getTurnUserReplyAttachmentContext(lockedUserMessage)
+        },
+        onSuccess: async (reply) => {
+          await persistCompletedReplyState(
+            authSession.channelId,
+            authSession.threadTs,
+            lockedSessionId,
+            reply
+          );
+        },
+        onPostDeliveryCommitFailure: async () => {
+          await failAgentTurnSessionCheckpoint({
+            conversationId: authSession.conversationId,
+            sessionId: lockedSessionId,
+            errorMessage: "OAuth-resumed MCP reply was delivered but completion state did not persist"
+          });
+        },
+        onFailure: async () => {
+          try {
+            await persistFailedReplyState(
+              authSession.channelId,
+              authSession.threadTs,
+              lockedSessionId
+            );
+          } catch (persistError) {
+            logException(
+              persistError,
+              "mcp_oauth_callback_resume_failure_persist_failed",
+              {},
+              { "app.credential.provider": provider },
+              "Failed to persist failed MCP resume state"
+            );
+          }
+        },
+        onAuthPause: async (error) => {
+          await persistAuthPauseTurnState({
+            sessionId: lockedSessionId,
+            threadStateId: threadId
+          });
+          logWarn(
+            "mcp_oauth_callback_resume_reparked_for_auth",
+            {},
+            {
+              "app.credential.provider": provider,
+              ...isRetryableTurnError(error) ? { "app.ai.retryable_reason": error.reason } : {}
+            },
+            "Resumed MCP turn requested another authorization flow"
+          );
+        },
+        onTimeoutPause: async (error) => {
+          if (!isRetryableTurnError(error, "turn_timeout_resume")) {
+            throw error;
+          }
+          const checkpointVersion = error.metadata?.checkpointVersion;
+          const nextSliceId = error.metadata?.sliceId;
+          if (typeof checkpointVersion !== "number") {
+            throw new Error(
+              "Timed-out MCP resume did not include a checkpoint version"
+            );
+          }
+          if (!canScheduleTurnTimeoutResume(nextSliceId)) {
+            logWarn(
+              "mcp_oauth_callback_resume_slice_limit_reached",
+              {},
+              {
+                "app.credential.provider": provider,
+                ...typeof nextSliceId === "number" ? { "app.ai.resume_slice_id": nextSliceId } : {}
+              },
+              "Skipped automatic timeout resume because the turn exceeded the slice limit"
+            );
+            throw new Error(
+              "Timed-out turn exceeded the automatic resume slice limit"
+            );
+          }
+          await scheduleTurnTimeoutResume({
+            conversationId: authSession.conversationId,
+            sessionId: lockedSessionId,
+            expectedCheckpointVersion: checkpointVersion
+          });
+        }
+      };
     }
   });
 }
@@ -15552,55 +15876,42 @@ async function publishAppHomeView(slackClient, userId, userTokenStore) {
 function htmlErrorResponse(title, message, status) {
   return htmlCallbackResponse(escapeXml(title), escapeXml(message), status);
 }
-async function buildCheckpointConversationContext(conversationId, sessionId) {
-  const conversation = coerceThreadConversationState(
-    await getPersistedThreadState(conversationId)
-  );
-  const userMessage = getTurnUserMessage(conversation, sessionId);
-  return buildConversationContext(conversation, {
-    excludeMessageId: userMessage?.id
-  });
-}
 async function persistCompletedOAuthReplyState(args) {
   const currentState = await getPersistedThreadState(args.conversationId);
   const conversation = coerceThreadConversationState(currentState);
   const artifacts = coerceThreadArtifactsState(currentState);
-  const nextArtifacts = args.reply.artifactStatePatch ? mergeArtifactsState(artifacts, args.reply.artifactStatePatch) : void 0;
   const userMessage = getTurnUserMessage(conversation, args.sessionId);
-  clearPendingAuth(conversation, args.sessionId);
-  markConversationMessage(conversation, userMessage?.id, {
-    replied: true,
-    skippedReason: void 0
-  });
-  upsertConversationMessage(conversation, {
-    id: generateConversationId("assistant"),
-    role: "assistant",
-    text: normalizeConversationText(args.reply.text) || "[empty response]",
-    createdAtMs: Date.now(),
-    author: {
-      userName: botConfig.userName,
-      isBot: true
-    },
-    meta: {
-      replied: true
-    }
-  });
-  if (args.reply.piMessages) {
-    conversation.piMessages = args.reply.piMessages;
-  }
-  markTurnCompleted({
+  const statePatch = buildDeliveredTurnStatePatch({
+    artifacts,
     conversation,
-    nowMs: Date.now(),
+    reply: args.reply,
     sessionId: args.sessionId,
-    updateConversationStats
+    userMessageId: userMessage?.id
   });
   await persistThreadStateById(args.conversationId, {
-    artifacts: nextArtifacts,
-    conversation,
-    sandboxId: args.reply.sandboxId,
-    sandboxDependencyProfileHash: args.reply.sandboxDependencyProfileHash
+    ...statePatch
   });
 }
+async function failCheckpointBestEffort2(args) {
+  try {
+    await failAgentTurnSessionCheckpoint({
+      conversationId: args.conversationId,
+      sessionId: args.sessionId,
+      errorMessage: args.errorMessage
+    });
+  } catch (error) {
+    logException(
+      error,
+      "oauth_callback_checkpoint_fail_persist_failed",
+      {},
+      {
+        "app.ai.conversation_id": args.conversationId,
+        "app.ai.session_id": args.sessionId
+      },
+      "Failed to mark OAuth-resumed turn checkpoint failed"
+    );
+  }
+}
 async function persistFailedOAuthReplyState(args) {
   const currentState = await getPersistedThreadState(args.conversationId);
   const conversation = coerceThreadConversationState(currentState);
@@ -15613,6 +15924,11 @@ async function persistFailedOAuthReplyState(args) {
     markConversationMessage,
     updateConversationStats
   });
+  await failCheckpointBestEffort2({
+    conversationId: args.conversationId,
+    sessionId: args.sessionId,
+    errorMessage: "OAuth-resumed turn failed"
+  });
   await persistThreadStateById(args.conversationId, {
     conversation
   });
@@ -15638,7 +15954,6 @@ async function resumeCheckpointedOAuthTurn(stored) {
     stored.resumeConversationId
   );
   const conversation = coerceThreadConversationState(currentState);
-  const artifacts = coerceThreadArtifactsState(currentState);
   const pendingAuth = getConversationPendingAuth({
     conversation,
     kind: "plugin",
@@ -15671,102 +15986,163 @@ async function resumeCheckpointedOAuthTurn(stored) {
   if (!userMessage?.author?.userId || !resolvedSessionId) {
     return false;
   }
-  const conversationContext = await buildCheckpointConversationContext(
-    stored.resumeConversationId,
-    resolvedSessionId
-  );
-  const channelConfiguration = getChannelConfigurationServiceById(
-    stored.channelId
-  );
   await resumeSlackTurn({
     messageText: stored.pendingMessage ?? userMessage.text,
     channelId: stored.channelId,
     threadTs: stored.threadTs,
     messageTs: getTurnUserSlackMessageTs(userMessage),
     lockKey: stored.resumeConversationId,
-    initialText: "",
-    replyContext: {
-      requester: {
-        userId: userMessage.author.userId,
-        userName: userMessage.author.userName,
-        fullName: userMessage.author.fullName
-      },
-      correlation: {
-        conversationId: stored.resumeConversationId,
-        turnId: resolvedSessionId,
-        channelId: stored.channelId,
-        threadTs: stored.threadTs,
-        requesterId: userMessage.author.userId
-      },
-      toolChannelId: artifacts.assistantContextChannelId ?? stored.channelId,
-      artifactState: artifacts,
-      pendingAuth,
-      conversationContext,
-      channelConfiguration,
-      piMessages: conversation.piMessages,
-      sandbox: getPersistedSandboxState(currentState),
-      onAuthPending: async (nextPendingAuth) => {
-        await applyPendingAuthUpdate({
-          conversation,
-          conversationId: stored.resumeConversationId,
-          nextPendingAuth
-        });
-        await persistThreadStateById(stored.resumeConversationId, {
-          conversation
-        });
-      },
-      ...getTurnUserReplyAttachmentContext(userMessage)
-    },
-    onSuccess: async (reply) => {
-      logInfo(
-        "oauth_callback_resume_complete",
-        {},
-        {
-          "app.credential.provider": stored.provider,
-          "app.ai.outcome": reply.diagnostics.outcome,
-          "app.ai.tool_calls": reply.diagnostics.toolCalls.length
-        },
-        "OAuth callback auto-resumed checkpoint finished replying"
-      );
-      await persistCompletedOAuthReplyState({
-        conversationId: stored.resumeConversationId,
-        sessionId: resolvedSessionId,
-        reply
-      });
-    },
-    onFailure: async () => {
-      await persistFailedOAuthReplyState({
-        conversationId: stored.resumeConversationId,
-        sessionId: resolvedSessionId
-      });
-    },
-    onAuthPause: async () => {
-      await persistAuthPauseTurnState({
-        sessionId: resolvedSessionId,
-        threadStateId: stored.resumeConversationId
+    initialText: "",
+    beforeStart: async () => {
+      const lockedCheckpoint = await getAgentTurnSessionCheckpoint(
+        stored.resumeConversationId,
+        stored.resumeSessionId
+      );
+      if (!lockedCheckpoint || lockedCheckpoint.state !== "awaiting_resume" || lockedCheckpoint.resumeReason !== "auth") {
+        return false;
+      }
+      const lockedState = await getPersistedThreadState(
+        stored.resumeConversationId
+      );
+      const lockedConversation = coerceThreadConversationState(lockedState);
+      const lockedArtifacts = coerceThreadArtifactsState(lockedState);
+      const lockedPendingAuth = getConversationPendingAuth({
+        conversation: lockedConversation,
+        kind: "plugin",
+        provider: stored.provider,
+        requesterId: stored.userId
       });
-    },
-    onTimeoutPause: async (error) => {
-      if (!isRetryableTurnError(error, "turn_timeout_resume")) {
-        throw error;
+      const lockedSessionId = lockedPendingAuth?.sessionId ?? stored.resumeSessionId;
+      if (lockedSessionId !== resolvedSessionId) {
+        return false;
       }
-      const checkpointVersion = error.metadata?.checkpointVersion;
-      const nextSliceId = error.metadata?.sliceId;
-      if (typeof checkpointVersion !== "number") {
-        throw new Error(
-          "Timed-out OAuth resume did not include a checkpoint version"
-        );
+      if (lockedPendingAuth) {
+        if (!isPendingAuthLatestRequest(lockedConversation, lockedPendingAuth)) {
+          clearPendingAuth(lockedConversation, lockedPendingAuth.sessionId);
+          await persistThreadStateById(stored.resumeConversationId, {
+            conversation: lockedConversation
+          });
+          await supersedeAgentTurnSessionCheckpoint({
+            conversationId: stored.resumeConversationId,
+            sessionId: lockedPendingAuth.sessionId,
+            errorMessage: "Auth completed after a newer thread message superseded this blocked request."
+          });
+          return false;
+        }
+      } else if (lockedConversation.processing.activeTurnId !== stored.resumeSessionId) {
+        return false;
       }
-      if (!canScheduleTurnTimeoutResume(nextSliceId)) {
-        throw new Error(
-          "Timed-out turn exceeded the automatic resume slice limit"
-        );
+      const lockedUserMessage = getTurnUserMessage(
+        lockedConversation,
+        lockedSessionId
+      );
+      if (!lockedUserMessage?.author?.userId) {
+        return false;
       }
-      await scheduleTurnTimeoutResume({
-        conversationId: stored.resumeConversationId,
-        sessionId: resolvedSessionId,
-        expectedCheckpointVersion: checkpointVersion
-      });
+      const lockedConversationContext = buildConversationContext(
+        lockedConversation,
+        {
+          excludeMessageId: lockedUserMessage.id
+        }
+      );
+      const lockedChannelConfiguration = getChannelConfigurationServiceById(
+        stored.channelId
+      );
+      return {
+        messageText: stored.pendingMessage ?? lockedUserMessage.text,
+        messageTs: getTurnUserSlackMessageTs(lockedUserMessage),
+        replyContext: {
+          requester: {
+            userId: lockedUserMessage.author.userId,
+            userName: lockedUserMessage.author.userName,
+            fullName: lockedUserMessage.author.fullName
+          },
+          correlation: {
+            conversationId: stored.resumeConversationId,
+            turnId: lockedSessionId,
+            channelId: stored.channelId,
+            threadTs: stored.threadTs,
+            requesterId: lockedUserMessage.author.userId
+          },
+          toolChannelId: lockedArtifacts.assistantContextChannelId ?? stored.channelId,
+          artifactState: lockedArtifacts,
+          pendingAuth: lockedPendingAuth,
+          conversationContext: lockedConversationContext,
+          channelConfiguration: lockedChannelConfiguration,
+          piMessages: lockedConversation.piMessages,
+          sandbox: getPersistedSandboxState(lockedState),
+          onAuthPending: async (nextPendingAuth) => {
+            await applyPendingAuthUpdate({
+              conversation: lockedConversation,
+              conversationId: stored.resumeConversationId,
+              nextPendingAuth
+            });
+            await persistThreadStateById(stored.resumeConversationId, {
+              conversation: lockedConversation
+            });
+          },
+          ...getTurnUserReplyAttachmentContext(lockedUserMessage)
+        },
+        onSuccess: async (reply) => {
+          logInfo(
+            "oauth_callback_resume_complete",
+            {},
+            {
+              "app.credential.provider": stored.provider,
+              "app.ai.outcome": reply.diagnostics.outcome,
+              "app.ai.tool_calls": reply.diagnostics.toolCalls.length
+            },
+            "OAuth callback auto-resumed checkpoint finished replying"
+          );
+          await persistCompletedOAuthReplyState({
+            conversationId: stored.resumeConversationId,
+            sessionId: lockedSessionId,
+            reply
+          });
+        },
+        onPostDeliveryCommitFailure: async () => {
+          await failAgentTurnSessionCheckpoint({
+            conversationId: stored.resumeConversationId,
+            expectedCheckpointVersion: lockedCheckpoint.checkpointVersion,
+            sessionId: lockedSessionId,
+            errorMessage: "OAuth-resumed reply was delivered but completion state did not persist"
+          });
+        },
+        onFailure: async () => {
+          await persistFailedOAuthReplyState({
+            conversationId: stored.resumeConversationId,
+            sessionId: lockedSessionId
+          });
+        },
+        onAuthPause: async () => {
+          await persistAuthPauseTurnState({
+            sessionId: lockedSessionId,
+            threadStateId: stored.resumeConversationId
+          });
+        },
+        onTimeoutPause: async (error) => {
+          if (!isRetryableTurnError(error, "turn_timeout_resume")) {
+            throw error;
+          }
+          const checkpointVersion = error.metadata?.checkpointVersion;
+          const nextSliceId = error.metadata?.sliceId;
+          if (typeof checkpointVersion !== "number") {
+            throw new Error(
+              "Timed-out OAuth resume did not include a checkpoint version"
+            );
+          }
+          if (!canScheduleTurnTimeoutResume(nextSliceId)) {
+            throw new Error(
+              "Timed-out turn exceeded the automatic resume slice limit"
+            );
+          }
+          await scheduleTurnTimeoutResume({
+            conversationId: stored.resumeConversationId,
+            sessionId: lockedSessionId,
+            expectedCheckpointVersion: checkpointVersion
+          });
+        }
+      };
     }
   });
   return true;
@@ -16522,7 +16898,7 @@ function isSandboxEgressRequest(request) {
 
 // src/handlers/turn-resume.ts
 var TIMEOUT_RESUME_LOCK_RETRY_DELAYS_MS = [250, 1e3, 2e3];
-function sleep3(ms) {
+function sleep4(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function persistCompletedReplyState2(args) {
@@ -16531,45 +16907,42 @@ async function persistCompletedReplyState2(args) {
   );
   const conversation = coerceThreadConversationState(currentState);
   const artifacts = coerceThreadArtifactsState(currentState);
-  const nextArtifacts = args.reply.artifactStatePatch ? mergeArtifactsState(artifacts, args.reply.artifactStatePatch) : void 0;
   const userMessage = getTurnUserMessage(
     conversation,
     args.checkpoint.sessionId
   );
-  clearPendingAuth(conversation, args.checkpoint.sessionId);
-  markConversationMessage(conversation, userMessage?.id, {
-    replied: true,
-    skippedReason: void 0
-  });
-  upsertConversationMessage(conversation, {
-    id: generateConversationId("assistant"),
-    role: "assistant",
-    text: normalizeConversationText(args.reply.text) || "[empty response]",
-    createdAtMs: Date.now(),
-    author: {
-      userName: botConfig.userName,
-      isBot: true
-    },
-    meta: {
-      replied: true
-    }
-  });
-  if (args.reply.piMessages) {
-    conversation.piMessages = args.reply.piMessages;
-  }
-  markTurnCompleted({
+  const statePatch = buildDeliveredTurnStatePatch({
+    artifacts,
     conversation,
-    nowMs: Date.now(),
+    reply: args.reply,
     sessionId: args.checkpoint.sessionId,
-    updateConversationStats
+    userMessageId: userMessage?.id
   });
   await persistThreadStateById(args.checkpoint.conversationId, {
-    artifacts: nextArtifacts,
-    conversation,
-    sandboxId: args.reply.sandboxId,
-    sandboxDependencyProfileHash: args.reply.sandboxDependencyProfileHash
+    ...statePatch
   });
 }
+async function failCheckpointBestEffort3(args) {
+  try {
+    await failAgentTurnSessionCheckpoint({
+      conversationId: args.checkpoint.conversationId,
+      expectedCheckpointVersion: args.checkpoint.checkpointVersion,
+      sessionId: args.checkpoint.sessionId,
+      errorMessage: args.errorMessage
+    });
+  } catch (error) {
+    logException(
+      error,
+      "timeout_resume_checkpoint_fail_persist_failed",
+      {},
+      {
+        "app.ai.conversation_id": args.checkpoint.conversationId,
+        "app.ai.session_id": args.checkpoint.sessionId
+      },
+      "Failed to mark timed-out turn checkpoint failed"
+    );
+  }
+}
 async function persistFailedReplyState2(checkpoint) {
   const currentState = await getPersistedThreadState(checkpoint.conversationId);
   const conversation = coerceThreadConversationState(currentState);
@@ -16582,145 +16955,152 @@ async function persistFailedReplyState2(checkpoint) {
     markConversationMessage,
     updateConversationStats
   });
+  await failCheckpointBestEffort3({
+    checkpoint,
+    errorMessage: "Timed-out turn failed while resuming"
+  });
   await persistThreadStateById(checkpoint.conversationId, {
     conversation
   });
 }
 async function resumeTimedOutTurn(payload) {
-  const checkpoint = await getAgentTurnSessionCheckpoint(
-    payload.conversationId,
-    payload.sessionId
-  );
-  if (!checkpoint || checkpoint.state !== "awaiting_resume" || checkpoint.resumeReason !== "timeout" || checkpoint.checkpointVersion !== payload.expectedCheckpointVersion) {
-    return;
-  }
   const thread = parseSlackThreadId(payload.conversationId);
   if (!thread) {
     throw new Error(
       `Timeout resume requires a Slack thread conversation id, got "${payload.conversationId}"`
     );
   }
-  const currentState = await getPersistedThreadState(payload.conversationId);
-  const conversation = coerceThreadConversationState(currentState);
-  const artifacts = coerceThreadArtifactsState(currentState);
-  const userMessage = getTurnUserMessage(conversation, payload.sessionId);
-  if (!userMessage?.author?.userId) {
-    throw new Error(
-      `Unable to locate the persisted user message for timeout resume session "${payload.sessionId}"`
-    );
-  }
-  if (conversation.processing.activeTurnId !== payload.sessionId) {
-    return;
-  }
-  const channelConfiguration = getChannelConfigurationServiceById(
-    thread.channelId
-  );
-  const conversationContext = buildConversationContext(conversation, {
-    excludeMessageId: userMessage.id
-  });
-  const sandbox = getPersistedSandboxState(currentState);
   await resumeSlackTurn({
-    messageText: userMessage.text,
+    messageText: "",
     channelId: thread.channelId,
     threadTs: thread.threadTs,
     lockKey: payload.conversationId,
-    replyContext: {
-      requester: {
-        userId: userMessage.author.userId,
-        userName: userMessage.author.userName,
-        fullName: userMessage.author.fullName
-      },
-      correlation: {
-        conversationId: payload.conversationId,
-        turnId: payload.sessionId,
-        channelId: thread.channelId,
-        threadTs: thread.threadTs,
-        requesterId: userMessage.author.userId
-      },
-      toolChannelId: artifacts.assistantContextChannelId ?? thread.channelId,
-      artifactState: artifacts,
-      pendingAuth: conversation.processing.pendingAuth,
-      conversationContext,
-      channelConfiguration,
-      piMessages: conversation.piMessages,
-      sandbox,
-      onAuthPending: async (nextPendingAuth) => {
-        await applyPendingAuthUpdate({
-          conversation,
-          conversationId: payload.conversationId,
-          nextPendingAuth
-        });
-        await persistThreadStateById(payload.conversationId, {
-          conversation
-        });
-      },
-      ...getTurnUserReplyAttachmentContext(userMessage)
-    },
-    onSuccess: async (reply) => {
-      try {
-        await persistCompletedReplyState2({ checkpoint, reply });
-      } catch (persistError) {
-        logException(
-          persistError,
-          "timeout_resume_complete_persist_failed",
-          {},
-          {
-            "app.ai.conversation_id": payload.conversationId,
-            "app.ai.session_id": payload.sessionId
-          },
-          "Failed to persist completed timeout-resume state after reply delivery"
-        );
-      }
-    },
-    onFailure: async () => {
-      await persistFailedReplyState2(checkpoint);
-    },
-    onAuthPause: async () => {
-      await persistAuthPauseTurnState({
-        sessionId: payload.sessionId,
-        threadStateId: payload.conversationId
-      });
-      logWarn(
-        "timeout_resume_reparked_for_auth",
-        {},
-        {
-          "app.ai.conversation_id": payload.conversationId,
-          "app.ai.session_id": payload.sessionId
-        },
-        "Resumed timed-out turn parked for auth"
+    beforeStart: async () => {
+      const checkpoint = await getAgentTurnSessionCheckpoint(
+        payload.conversationId,
+        payload.sessionId
       );
-    },
-    onTimeoutPause: async (error) => {
-      if (!isRetryableTurnError(error, "turn_timeout_resume")) {
-        throw error;
+      if (!checkpoint || checkpoint.state !== "awaiting_resume" || checkpoint.resumeReason !== "timeout" || checkpoint.checkpointVersion !== payload.expectedCheckpointVersion) {
+        return false;
       }
-      const checkpointVersion = error.metadata?.checkpointVersion;
-      const nextSliceId = error.metadata?.sliceId;
-      if (typeof checkpointVersion !== "number") {
+      const currentState = await getPersistedThreadState(
+        payload.conversationId
+      );
+      const conversation = coerceThreadConversationState(currentState);
+      const artifacts = coerceThreadArtifactsState(currentState);
+      const userMessage = getTurnUserMessage(conversation, payload.sessionId);
+      if (!userMessage?.author?.userId) {
         throw new Error(
-          "Timed-out resume turn did not include a checkpoint version"
+          `Unable to locate the persisted user message for timeout resume session "${payload.sessionId}"`
         );
       }
-      if (!canScheduleTurnTimeoutResume(nextSliceId)) {
-        logWarn(
-          "timeout_resume_slice_limit_reached",
-          {},
-          {
-            "app.ai.conversation_id": payload.conversationId,
-            "app.ai.session_id": payload.sessionId,
-            ...typeof nextSliceId === "number" ? { "app.ai.resume_slice_id": nextSliceId } : {}
-          },
-          "Skipped automatic timeout resume because the turn exceeded the slice limit"
-        );
-        throw new Error(
-          "Timed-out turn exceeded the automatic resume slice limit"
-        );
+      if (conversation.processing.activeTurnId !== payload.sessionId) {
+        return false;
       }
-      await scheduleTurnTimeoutResume({
-        conversationId: payload.conversationId,
-        sessionId: payload.sessionId,
-        expectedCheckpointVersion: checkpointVersion
+      const channelConfiguration = getChannelConfigurationServiceById(
+        thread.channelId
+      );
+      const conversationContext = buildConversationContext(conversation, {
+        excludeMessageId: userMessage.id
       });
+      const sandbox = getPersistedSandboxState(currentState);
+      return {
+        messageText: userMessage.text,
+        messageTs: getTurnUserSlackMessageTs(userMessage),
+        replyContext: {
+          requester: {
+            userId: userMessage.author.userId,
+            userName: userMessage.author.userName,
+            fullName: userMessage.author.fullName
+          },
+          correlation: {
+            conversationId: payload.conversationId,
+            turnId: payload.sessionId,
+            channelId: thread.channelId,
+            threadTs: thread.threadTs,
+            requesterId: userMessage.author.userId
+          },
+          toolChannelId: artifacts.assistantContextChannelId ?? thread.channelId,
+          artifactState: artifacts,
+          pendingAuth: conversation.processing.pendingAuth,
+          conversationContext,
+          channelConfiguration,
+          piMessages: conversation.piMessages,
+          sandbox,
+          onAuthPending: async (nextPendingAuth) => {
+            await applyPendingAuthUpdate({
+              conversation,
+              conversationId: payload.conversationId,
+              nextPendingAuth
+            });
+            await persistThreadStateById(payload.conversationId, {
+              conversation
+            });
+          },
+          ...getTurnUserReplyAttachmentContext(userMessage)
+        },
+        onSuccess: async (reply) => {
+          await persistCompletedReplyState2({ checkpoint, reply });
+        },
+        onFailure: async () => {
+          await persistFailedReplyState2(checkpoint);
+        },
+        onPostDeliveryCommitFailure: async () => {
+          await failAgentTurnSessionCheckpoint({
+            conversationId: checkpoint.conversationId,
+            expectedCheckpointVersion: checkpoint.checkpointVersion,
+            sessionId: checkpoint.sessionId,
+            errorMessage: "Timed-out turn reply was delivered but completion state did not persist"
+          });
+        },
+        onAuthPause: async () => {
+          await persistAuthPauseTurnState({
+            sessionId: payload.sessionId,
+            threadStateId: payload.conversationId
+          });
+          logWarn(
+            "timeout_resume_reparked_for_auth",
+            {},
+            {
+              "app.ai.conversation_id": payload.conversationId,
+              "app.ai.session_id": payload.sessionId
+            },
+            "Resumed timed-out turn parked for auth"
+          );
+        },
+        onTimeoutPause: async (error) => {
+          if (!isRetryableTurnError(error, "turn_timeout_resume")) {
+            throw error;
+          }
+          const checkpointVersion = error.metadata?.checkpointVersion;
+          const nextSliceId = error.metadata?.sliceId;
+          if (typeof checkpointVersion !== "number") {
+            throw new Error(
+              "Timed-out resume turn did not include a checkpoint version"
+            );
+          }
+          if (!canScheduleTurnTimeoutResume(nextSliceId)) {
+            logWarn(
+              "timeout_resume_slice_limit_reached",
+              {},
+              {
+                "app.ai.conversation_id": payload.conversationId,
+                "app.ai.session_id": payload.sessionId,
+                ...typeof nextSliceId === "number" ? { "app.ai.resume_slice_id": nextSliceId } : {}
+              },
+              "Skipped automatic timeout resume because the turn exceeded the slice limit"
+            );
+            throw new Error(
+              "Timed-out turn exceeded the automatic resume slice limit"
+            );
+          }
+          await scheduleTurnTimeoutResume({
+            conversationId: payload.conversationId,
+            sessionId: payload.sessionId,
+            expectedCheckpointVersion: checkpointVersion
+          });
+        }
+      };
     }
   });
 }
@@ -16745,8 +17125,9 @@ async function resumeTimedOutTurnWithLockRetry(payload) {
             "app.ai.session_id": payload.sessionId,
             "app.ai.resume_lock_retry_count": attempt
           },
-          "Skipped timeout resume because another turn still owns the thread lock"
+          "Rescheduling timeout resume because another turn still owns the thread lock"
         );
+        await scheduleTurnTimeoutResume(payload);
         return;
       }
       logWarn(
@@ -16760,7 +17141,7 @@ async function resumeTimedOutTurnWithLockRetry(payload) {
         },
         "Timeout resume lock was busy; retrying"
       );
-      await sleep3(delayMs);
+      await sleep4(delayMs);
     }
   }
 }
@@ -18260,6 +18641,31 @@ function getCurrentTurnCanvasUrl(args) {
 function buildCanvasRecoveryReply(canvasUrl) {
   return `I created the canvas, but the turn was interrupted before I could finish the thread reply: ${canvasUrl}`;
 }
+async function loadPiMessagesForTurn(args) {
+  const fallback = args.fallback.length > 0 ? [...args.fallback] : void 0;
+  if (!args.conversationId) {
+    return fallback;
+  }
+  if (args.activeTurnId) {
+    const checkpoint2 = await getAgentTurnSessionCheckpoint(
+      args.conversationId,
+      args.activeTurnId
+    );
+    if (checkpoint2?.piMessages.length) {
+      return stripRuntimeTurnContext(
+        trimTrailingAssistantMessages(checkpoint2.piMessages)
+      );
+    }
+  }
+  if (!args.lastSessionId) {
+    return fallback;
+  }
+  const checkpoint = await getAgentTurnSessionCheckpoint(
+    args.conversationId,
+    args.lastSessionId
+  );
+  return checkpoint?.state === "completed" && checkpoint.piMessages.length > 0 ? stripRuntimeTurnContext(checkpoint.piMessages) : fallback;
+}
 function createReplyToThread(deps) {
   return async function replyToThread(thread, message, options = {}) {
     if (message.author.isMe) {
@@ -18412,6 +18818,7 @@ function createReplyToThread(deps) {
             return;
           }
         }
+        const lastSessionIdForHistory = preparedState.conversation.processing.lastSessionId;
         const configReply = await maybeApplyProviderDefaultConfigRequest({
           channelConfiguration: preparedState.channelConfiguration,
           requesterId: message.author.userId,
@@ -18487,6 +18894,12 @@ function createReplyToThread(deps) {
           }
         );
         const omittedImageAttachmentCount = !isVisionEnabled() && hasPotentialImageAttachment(message.attachments) ? countPotentialImageAttachments(message.attachments) : 0;
+        const piMessages = await loadPiMessagesForTurn({
+          conversationId,
+          activeTurnId,
+          lastSessionId: lastSessionIdForHistory,
+          fallback: preparedState.conversation.piMessages
+        });
         const status = createSlackAdapterAssistantStatusSession({
           channelId: assistantThreadContext?.channelId,
           threadTs: assistantThreadContext?.threadTs,
@@ -18538,7 +18951,7 @@ function createReplyToThread(deps) {
             },
             conversationContext: preparedState.routingContext ?? preparedState.conversationContext,
             artifactState: preparedState.artifacts,
-            piMessages: preparedState.conversation.piMessages,
+            piMessages,
             pendingAuth: preparedState.conversation.processing.pendingAuth,
             configuration: preparedState.configuration,
             channelConfiguration: preparedState.channelConfiguration,
@@ -18600,30 +19013,6 @@ function createReplyToThread(deps) {
               context: diagnosticsContext
             });
           }
-          markConversationMessage(
-            preparedState.conversation,
-            preparedState.userMessageId,
-            {
-              replied: true,
-              skippedReason: void 0
-            }
-          );
-          upsertConversationMessage(preparedState.conversation, {
-            id: generateConversationId("assistant"),
-            role: "assistant",
-            text: normalizeConversationText(reply.text) || "[empty response]",
-            createdAtMs: Date.now(),
-            author: {
-              userName: botConfig.userName,
-              isBot: true
-            },
-            meta: {
-              replied: true
-            }
-          });
-          if (reply.piMessages) {
-            preparedState.conversation.piMessages = reply.piMessages;
-          }
           const artifactStatePatch = reply.artifactStatePatch ? { ...reply.artifactStatePatch } : {};
           const reactionPerformed = reply.diagnostics.toolCalls.includes(
             "slackMessageAddReaction"
@@ -18696,19 +19085,18 @@ function createReplyToThread(deps) {
           if (titleUpdateResult) {
             artifactStatePatch.assistantTitleSourceMessageId = titleUpdateResult;
           }
-          const shouldPersistArtifacts = Object.keys(artifactStatePatch).length > 0;
-          const nextArtifacts = shouldPersistArtifacts ? mergeArtifactsState(preparedState.artifacts, artifactStatePatch) : void 0;
-          markTurnCompleted({
+          const completedState = buildDeliveredTurnStatePatch({
+            artifactStatePatch,
+            artifacts: preparedState.artifacts,
             conversation: preparedState.conversation,
-            nowMs: Date.now(),
-            updateConversationStats
+            reply,
+            sessionId: turnId,
+            userMessageId: preparedState.userMessageId
           });
           await persistThreadState(thread, {
-            artifacts: nextArtifacts,
-            conversation: preparedState.conversation,
-            sandboxId: reply.sandboxId,
-            sandboxDependencyProfileHash: reply.sandboxDependencyProfileHash
+            ...completedState
           });
+          preparedState.conversation = completedState.conversation;
           persistedAtLeastOnce = true;
           if (shouldEmitDevAgentTrace()) {
             logInfo(
@@ -18826,9 +19214,10 @@ function createReplyToThread(deps) {
                 replied: true
               }
             });
-            markTurnCompleted({
+            markTurnClosed({
               conversation: preparedState.conversation,
               nowMs: Date.now(),
+              sessionId: turnId,
               updateConversationStats
             });
             await persistThreadState(thread, {
@@ -18845,12 +19234,30 @@ function createReplyToThread(deps) {
             markTurnFailed({
               conversation: preparedState.conversation,
               nowMs: Date.now(),
+              sessionId: turnId,
               userMessageId: preparedState.userMessageId,
               markConversationMessage: (conversation, messageId, patch) => {
                 markConversationMessage(conversation, messageId, patch);
               },
               updateConversationStats
             });
+            if (conversationId) {
+              try {
+                await failAgentTurnSessionCheckpoint({
+                  conversationId,
+                  sessionId: turnId,
+                  errorMessage: "Agent turn failed before final reply delivery completed"
+                });
+              } catch (checkpointError) {
+                logException(
+                  checkpointError,
+                  "agent_turn_failed_checkpoint_persist_failed",
+                  turnTraceContext,
+                  {},
+                  "Failed to mark failed turn checkpoint"
+                );
+              }
+            }
             await persistThreadState(thread, {
               conversation: preparedState.conversation
             });
@@ -19983,22 +20390,67 @@ async function resolveBuildPluginConfig() {
   try {
     const mod = await import("#junior/config");
     return mod.plugins;
-  } catch {
-    const env = process.env.JUNIOR_PLUGIN_PACKAGES;
-    if (env) {
-      try {
-        return { packages: JSON.parse(env) };
-      } catch {
-      }
+  } catch (error) {
+    if (!isMissingVirtualConfig(error)) {
+      throw error;
+    }
+    const packages = readEnvPluginPackages();
+    if (packages) {
+      return { packages };
     }
     return void 0;
   }
 }
+function isMissingVirtualConfig(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const code = error.code;
+  return (code === "ERR_PACKAGE_IMPORT_NOT_DEFINED" || code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") && error.message.includes("#junior/config");
+}
+function readEnvPluginPackages() {
+  const env = process.env.JUNIOR_PLUGIN_PACKAGES;
+  if (!env) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(env);
+  } catch (error) {
+    throw new Error("JUNIOR_PLUGIN_PACKAGES must be valid JSON", {
+      cause: error
+    });
+  }
+  if (!Array.isArray(parsed) || parsed.some((value) => typeof value !== "string" || !value.trim())) {
+    throw new Error(
+      "JUNIOR_PLUGIN_PACKAGES must be a JSON array of package names"
+    );
+  }
+  return parsed;
+}
+function hasConfiguredPluginCatalog(config) {
+  if (!config) {
+    return false;
+  }
+  return Boolean(
+    config.packages?.length || Object.keys(config.manifests ?? {}).length
+  );
+}
 async function createApp(options) {
   const pluginConfig = options?.plugins ?? await resolveBuildPluginConfig();
-  setPluginPackages(pluginConfig?.packages);
-  setPluginConfig(pluginConfig);
-  setConfigDefaults(options?.configDefaults);
+  const shouldValidatePluginCatalog = hasConfiguredPluginCatalog(pluginConfig) || Boolean(Object.keys(options?.configDefaults ?? {}).length);
+  const previousPluginConfig = setPluginConfig(pluginConfig);
+  const previousConfigDefaults = getConfigDefaults();
+  try {
+    setConfigDefaults(options?.configDefaults);
+    if (shouldValidatePluginCatalog) {
+      getPluginCatalogSignature();
+    }
+  } catch (error) {
+    setPluginConfig(previousPluginConfig);
+    setConfigDefaults(previousConfigDefaults);
+    throw error;
+  }
   const waitUntil = options?.waitUntil ?? await defaultWaitUntil();
   const app = new Hono();
   app.onError((err, c) => {