@sentry/junior 0.53.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(),
@@ -1479,6 +1490,9 @@ var StateBackedMcpOAuthClientProvider = class {
     this.sessionContext = sessionContext;
     this.clientMetadata = createClientMetadata(callbackUrl);
   }
+  authSessionId;
+  callbackUrl;
+  sessionContext;
   clientMetadata;
   get redirectUrl() {
     return this.callbackUrl;
@@ -2128,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;
@@ -2451,589 +2432,1015 @@ 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/turn-context-tag.ts
-var TURN_CONTEXT_TAG = "runtime-turn-context";
+// 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}`;
 }
-
-// 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()}...`;
+function parsePiMessage(value) {
+  return isRecord(value) ? value : 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("");
+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;
     }
-    result.push(line);
   }
-  return result.join("\n");
+  return limit;
 }
-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();
+async function loadPiSessionMessages(args) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  const messageCount = normalizeMessageCount(args.messageCount);
+  if (messageCount === 0) {
+    return [];
+  }
+  const values = await Promise.all(
+    Array.from(
+      { length: messageCount },
+      (_, index) => stateAdapter.get(piSessionMessageKey(args, index))
+    )
+  );
+  const messages = [];
+  for (const value of values) {
+    const message = parsePiMessage(value);
+    if (!message) {
+      break;
+    }
+    messages.push(message);
+  }
+  return messages.length === messageCount ? messages : void 0;
 }
-function normalizeSlackStatusText(text) {
-  const trimmed = text.trim();
-  if (!trimmed) {
-    return "";
+async function loadExistingPiSessionMessages(scope, maxCount) {
+  const count = normalizeMessageCount(maxCount);
+  if (count === 0) {
+    return [];
   }
-  return truncateStatusText(trimmed.replace(/(?:\.\s*)+$/, "").trim());
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  const values = await Promise.all(
+    Array.from(
+      { length: count },
+      (_, index) => stateAdapter.get(piSessionMessageKey(scope, index))
+    )
+  );
+  const messages = [];
+  for (const value of values) {
+    const message = parsePiMessage(value);
+    if (!message) {
+      break;
+    }
+    messages.push(message);
+  }
+  return messages;
+}
+async function commitPiSessionMessages(args) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  const existingMessages = await loadExistingPiSessionMessages(
+    { conversationId: args.conversationId, sessionId: args.sessionId },
+    args.messages.length
+  );
+  const writeFromIndex = countMatchingPrefix(existingMessages, args.messages);
+  await Promise.all(
+    args.messages.slice(writeFromIndex).map(
+      (message, offset) => stateAdapter.set(
+        piSessionMessageKey(args, writeFromIndex + offset),
+        message,
+        args.ttlMs
+      )
+    )
+  );
 }
 
-// src/chat/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) {
-  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;
-    }
-    if (new RegExp(`^${open.fence}\\s*$`).test(trimmed)) {
-      open = void 0;
-    }
+function parseAgentTurnSessionRecord(value) {
+  const parsed = parseStoredRecord(value);
+  if (!parsed) {
+    return void 0;
   }
-  if (!open) {
-    return null;
+  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 {
-    closeSuffix: text.endsWith("\n") ? open.fence : `
-${open.fence}`,
-    reopenPrefix: `${open.openerLine}
-`
+    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 appendSlackSuffix(text, marker) {
-  const carryover = getFenceContinuation(text);
-  return `${text}${carryover?.closeSuffix ?? ""}${marker}`;
-}
-function stripTrailingContinuationMarker(text) {
-  return text.endsWith(CONTINUED_MARKER) ? text.slice(0, -CONTINUED_MARKER.length) : text;
-}
-function takeSlackContinuationChunk(text, budget) {
-  let { prefix, rest } = takeSlackInlinePrefix(text, budget);
-  if (!rest) {
-    ({ prefix, rest } = takeSlackInlinePrefix(
-      text,
-      forceSplitBudget(text, budget)
-    ));
+function materializePiMessages(legacyPiMessages, messageCount, sessionMessages) {
+  if (messageCount === 0) {
+    return [];
   }
-  let carryover = rest ? getFenceContinuation(prefix) : null;
-  if (!carryover) {
-    return { prefix, rest };
+  if (sessionMessages) {
+    return sessionMessages;
   }
-  const carryoverBudget = reserveInlineBudgetForSuffix(
-    `${carryover.closeSuffix}${CONTINUED_MARKER}`
+  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)
   );
-  ({ prefix, rest } = takeSlackInlinePrefix(text, carryoverBudget));
-  if (!rest) {
-    ({ prefix, rest } = takeSlackInlinePrefix(
-      text,
-      forceSplitBudget(text, carryoverBudget)
-    ));
+  const parsed = parseAgentTurnSessionRecord(value);
+  if (!parsed) {
+    return void 0;
   }
-  carryover = rest ? getFenceContinuation(prefix) : null;
-  if (!carryover) {
-    return { prefix, rest };
+  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 {
-    prefix,
-    rest: `${carryover.reopenPrefix}${rest}`
+    ...parsed.record,
+    piMessages
   };
 }
-function takeSlackContinuationPrefix(text, options) {
-  const budget = {
-    maxChars: options?.maxChars ?? getSlackContinuationBudget().maxChars,
-    maxLines: options?.maxLines ?? getSlackContinuationBudget().maxLines
+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 } : {}
   };
-  const { prefix, rest } = (() => {
-    if (options?.forceSplit) {
-      return takeSlackContinuationChunk(text, budget);
-    }
-    const initial = takeSlackInlinePrefix(text, budget);
-    return initial.rest ? takeSlackContinuationChunk(text, budget) : initial;
-  })();
+  await stateAdapter.set(
+    agentTurnSessionKey(args.conversationId, args.sessionId),
+    checkpoint,
+    ttlMs
+  );
   return {
-    prefix,
-    renderedPrefix: rest ? appendSlackSuffix(prefix, CONTINUED_MARKER) : prefix,
-    rest
+    ...checkpoint,
+    piMessages: [...args.piMessages]
   };
 }
-function takeSlackInlinePrefix(text, options) {
-  const maxChars = options?.maxChars ?? MAX_INLINE_CHARS;
-  const maxLines = options?.maxLines ?? MAX_INLINE_LINES;
-  const normalized = text.replace(/\r\n?/g, "\n");
-  if (!normalized) {
-    return { prefix: "", rest: "" };
+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;
   }
-  if (fitsInlineBudget(normalized, maxChars, maxLines)) {
-    return { prefix: normalized, rest: "" };
+  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;
   }
-  const lineBounded = splitByLineBudget(normalized, maxLines);
-  const cutIndex = findSplitIndex(lineBounded, maxChars);
-  const prefix = lineBounded.slice(0, cutIndex).trimEnd();
-  if (prefix) {
-    return {
-      prefix,
-      rest: normalized.slice(prefix.length).trimStart()
-    };
+  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;
   }
-  const hardPrefix = normalized.slice(0, Math.max(1, maxChars)).trimEnd();
-  return {
-    prefix: hardPrefix || normalized.slice(0, Math.max(1, maxChars)),
-    rest: normalized.slice(hardPrefix.length || Math.max(1, maxChars)).trimStart()
-  };
+  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 splitSlackReplyText(text, options) {
-  const normalized = renderSlackMrkdwn(text);
-  if (!normalized) {
-    return [];
+function getConversationPendingAuth(args) {
+  const pendingAuth = args.conversation.processing.pendingAuth;
+  if (!pendingAuth) {
+    return void 0;
   }
-  const chunks = [];
-  const continuationBudget = reserveInlineBudgetForSuffix(CONTINUED_MARKER);
-  let remaining = normalized;
-  while (remaining) {
-    const fitsFinalChunk = options?.interrupted ? fitsInlineBudget(appendSlackSuffix(remaining, getInterruptionMarker())) : fitsInlineBudget(remaining);
-    if (fitsFinalChunk) {
-      chunks.push(
-        options?.interrupted ? appendSlackSuffix(remaining, getInterruptionMarker()) : remaining
-      );
-      break;
-    }
-    const { renderedPrefix, rest } = takeSlackContinuationPrefix(remaining, {
-      ...continuationBudget,
-      forceSplit: true
+  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."
     });
-    chunks.push(renderedPrefix);
-    remaining = rest;
   }
-  if (chunks.length === 2) {
-    chunks[0] = stripTrailingContinuationMarker(chunks[0] ?? "");
+}
+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 chunks;
+  return false;
 }
-function getSlackContinuationBudget() {
-  return reserveInlineBudgetForSuffix(CONTINUED_MARKER);
+
+// 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
+  };
 }
-function buildSlackOutputMessage(text, files) {
-  const normalized = renderSlackMrkdwn(text);
-  const fileCount = files?.length ?? 0;
-  if (!normalized) {
-    if (fileCount > 0) {
-      return {
-        raw: "",
-        files
-      };
+
+// 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;
     }
-    throw new Error(
-      `Slack output normalized to empty content: original_length=${text.length} parsed_length=${normalized.length}`
-    );
   }
+  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 {
-    markdown: normalized,
-    files
+    ...inboundAttachmentCount > 0 ? { inboundAttachmentCount } : {},
+    ...!imagesHydrated && imageAttachmentCount > 0 ? { omittedImageAttachmentCount: imageAttachmentCount } : {}
   };
 }
-var slackOutputPolicy = {
-  maxInlineChars: MAX_INLINE_CHARS,
-  maxInlineLines: MAX_INLINE_LINES
-};
+
+// src/chat/respond.ts
+import { Agent as Agent2 } from "@earendil-works/pi-agent-core";
 
 // src/chat/prompt.ts
-var DEFAULT_SOUL = "You are Junior, a practical and concise assistant.";
-function getLoggedMarkdownFiles() {
-  const globalState = globalThis;
-  globalState.__juniorLoggedMarkdownFiles ??= /* @__PURE__ */ new Set();
-  return globalState.__juniorLoggedMarkdownFiles;
+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;
 }
-function loadOptionalMarkdownFile(candidates, fileName) {
-  for (const resolved of candidates) {
-    try {
-      const raw = fs.readFileSync(resolved, "utf8").trim();
-      if (raw.length > 0) {
-        const loggedMarkdownFiles = getLoggedMarkdownFiles();
-        const logKey = `${fileName}:${resolved}`;
-        if (!loggedMarkdownFiles.has(logKey)) {
-          loggedMarkdownFiles.add(logKey);
-          logInfo(
-            `${fileName.toLowerCase()}_loaded`,
-            {},
-            {
-              "file.path": resolved
-            },
-            `Loaded ${fileName}`
-          );
+
+// 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("");
         }
-        return raw;
       }
-    } catch {
+      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 null;
+  return result.join("\n");
 }
-function loadSoul() {
-  const soul = loadOptionalMarkdownFile(soulPathCandidates(), "SOUL.md");
-  if (soul) {
-    return soul;
+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 "";
   }
-  logWarn(
-    "soul_load_fallback",
-    {},
-    {
-      "app.file.candidates": soulPathCandidates()
-    },
-    "SOUL.md not found; using built-in default personality"
-  );
-  return DEFAULT_SOUL;
+  return truncateStatusText(trimmed.replace(/(?:\.\s*)+$/, "").trim());
 }
-function loadWorld() {
-  return loadOptionalMarkdownFile(worldPathCandidates(), "WORLD.md");
+
+// 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;
 }
-var JUNIOR_PERSONALITY = (() => {
-  try {
-    return loadSoul();
-  } catch (error) {
-    logWarn(
-      "soul_load_failed",
-      {},
-      {
-        "exception.message": error instanceof Error ? error.message : String(error)
-      },
-      "Failed to load SOUL.md; using built-in default personality"
-    );
-    return DEFAULT_SOUL;
+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;
   }
-})();
-var JUNIOR_WORLD = (() => {
-  try {
-    return loadWorld();
-  } catch (error) {
-    logWarn(
-      "world_load_failed",
-      {},
-      {
-        "exception.message": error instanceof Error ? error.message : String(error)
-      },
-      "Failed to load WORLD.md; omitting world prompt context"
-    );
-    return null;
+  const bounded = text.slice(0, maxChars);
+  const newlineIndex = bounded.lastIndexOf("\n");
+  if (newlineIndex > 0) {
+    return newlineIndex;
   }
-})();
-function workspaceSkillDir(skillName) {
-  return sandboxSkillDir(skillName);
+  const spaceIndex = bounded.lastIndexOf(" ");
+  if (spaceIndex > 0) {
+    return spaceIndex;
+  }
+  return maxChars;
 }
-function formatConfigurationValue(value) {
-  if (typeof value === "string") {
-    return escapeXml(value);
+function splitByLineBudget(text, maxLines) {
+  if (maxLines <= 0) {
+    return "";
   }
-  try {
-    return escapeXml(JSON.stringify(value));
-  } catch {
-    return escapeXml(String(value));
+  const lines = text.split("\n");
+  if (lines.length <= maxLines) {
+    return text;
   }
+  return lines.slice(0, maxLines).join("\n");
 }
-function renderRequesterBlock(fields) {
-  const lines = Object.entries(fields).filter(([, value]) => Boolean(value)).map(([key, value]) => `- ${key}: ${escapeXml(value)}`);
-  if (lines.length === 0) {
+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;
+    }
+    if (new RegExp(`^${open.fence}\\s*$`).test(trimmed)) {
+      open = void 0;
+    }
+  }
+  if (!open) {
     return null;
   }
-  return ["<requester>", ...lines, "</requester>"];
+  return {
+    closeSuffix: text.endsWith("\n") ? open.fence : `
+${open.fence}`,
+    reopenPrefix: `${open.openerLine}
+`
+  };
 }
-function renderTag(tag, lines) {
-  return [`<${tag}>`, ...lines, `</${tag}>`];
+function appendSlackSuffix(text, marker) {
+  const carryover = getFenceContinuation(text);
+  return `${text}${carryover?.closeSuffix ?? ""}${marker}`;
 }
-function renderTagBlock(tag, content) {
-  return [`<${tag}>`, content, `</${tag}>`].join("\n");
+function stripTrailingContinuationMarker(text) {
+  return text.endsWith(CONTINUED_MARKER) ? text.slice(0, -CONTINUED_MARKER.length) : text;
 }
-function formatSkillEntry(skill) {
-  const skillLocation = `${workspaceSkillDir(skill.name)}/SKILL.md`;
-  const lines = [];
-  lines.push("  <skill>");
-  lines.push(`    <name>${escapeXml(skill.name)}</name>`);
-  lines.push(`    <description>${escapeXml(skill.description)}</description>`);
-  lines.push(`    <location>${escapeXml(skillLocation)}</location>`);
-  if (skill.pluginProvider) {
-    lines.push(`    <provider>${escapeXml(skill.pluginProvider)}</provider>`);
+function takeSlackContinuationChunk(text, budget) {
+  let { prefix, rest } = takeSlackInlinePrefix(text, budget);
+  if (!rest) {
+    ({ prefix, rest } = takeSlackInlinePrefix(
+      text,
+      forceSplitBudget(text, budget)
+    ));
   }
-  lines.push("  </skill>");
-  return lines;
-}
-function formatAvailableSkillsForPrompt(skills, invocation) {
-  const autoSelectable = skills.filter(
-    (s) => s.disableModelInvocation !== true
+  let carryover = rest ? getFenceContinuation(prefix) : null;
+  if (!carryover) {
+    return { prefix, rest };
+  }
+  const carryoverBudget = reserveInlineBudgetForSuffix(
+    `${carryover.closeSuffix}${CONTINUED_MARKER}`
   );
-  const invokedExplicitOnly = invocation ? skills.filter(
-    (s) => s.disableModelInvocation === true && s.name === invocation.skillName
-  ) : [];
-  const sections = [];
-  const available = [
-    "<available-skills>",
-    ...autoSelectable.length > 0 ? [
-      "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));
+  ({ prefix, rest } = takeSlackInlinePrefix(text, carryoverBudget));
+  if (!rest) {
+    ({ prefix, rest } = takeSlackInlinePrefix(
+      text,
+      forceSplitBudget(text, carryoverBudget)
+    ));
   }
-  available.push("</available-skills>");
-  sections.push(available.join("\n"));
-  if (invokedExplicitOnly.length > 0) {
-    const userCallable = [
-      "<user-callable-skills>",
-      "The user's current message explicitly references this skill by name. Load it when relevant to the request."
-    ];
-    for (const skill of invokedExplicitOnly) {
-      userCallable.push(...formatSkillEntry(skill));
-    }
-    userCallable.push("</user-callable-skills>");
-    sections.push(userCallable.join("\n"));
+  carryover = rest ? getFenceContinuation(prefix) : null;
+  if (!carryover) {
+    return { prefix, rest };
   }
-  return sections.join("\n");
+  return {
+    prefix,
+    rest: `${carryover.reopenPrefix}${rest}`
+  };
 }
-function formatLoadedSkillsForPrompt(skills) {
-  if (skills.length === 0) {
-    return "<loaded-skills>\n</loaded-skills>";
-  }
-  const lines = ["<loaded-skills>"];
-  for (const skill of skills) {
-    const skillDir = workspaceSkillDir(skill.name);
-    lines.push(
-      `  <skill name="${escapeXml(skill.name)}" location="${escapeXml(`${skillDir}/SKILL.md`)}">`
-    );
-    lines.push(
-      `Skill directory: ${escapeXml(skillDir)}. Resolve relative paths there; for skill-owned bash commands, cd there first or use absolute paths.`
-    );
-    lines.push("");
-    lines.push(skill.body);
-    lines.push("  </skill>");
-  }
-  lines.push("</loaded-skills>");
-  return lines.join("\n");
+function takeSlackContinuationPrefix(text, options) {
+  const budget = {
+    maxChars: options?.maxChars ?? getSlackContinuationBudget().maxChars,
+    maxLines: options?.maxLines ?? getSlackContinuationBudget().maxLines
+  };
+  const { prefix, rest } = (() => {
+    if (options?.forceSplit) {
+      return takeSlackContinuationChunk(text, budget);
+    }
+    const initial = takeSlackInlinePrefix(text, budget);
+    return initial.rest ? takeSlackContinuationChunk(text, budget) : initial;
+  })();
+  return {
+    prefix,
+    renderedPrefix: rest ? appendSlackSuffix(prefix, CONTINUED_MARKER) : prefix,
+    rest
+  };
 }
-function formatProviderCatalogForPrompt() {
-  const providers = getPluginProviders().map((plugin) => plugin.manifest);
-  if (providers.length === 0) {
-    return null;
-  }
-  const lines = [
-    "Config keys and default targets per provider; use after a skill is loaded. Run authenticated provider commands directly after resolving target defaults; let the runtime handle auth pauses/resumes."
-  ];
-  for (const provider of providers) {
-    lines.push(`- provider: ${escapeXml(provider.name)}`);
-    lines.push(
-      `  - config_keys: ${provider.configKeys.length > 0 ? escapeXml(provider.configKeys.join(", ")) : "none"}`
-    );
-    lines.push(
-      `  - default_context: ${provider.target ? escapeXml(
-        `${provider.target.type} via ${provider.target.configKey}`
-      ) : "none"}`
-    );
+function takeSlackInlinePrefix(text, options) {
+  const maxChars = options?.maxChars ?? MAX_INLINE_CHARS;
+  const maxLines = options?.maxLines ?? MAX_INLINE_LINES;
+  const normalized = text.replace(/\r\n?/g, "\n");
+  if (!normalized) {
+    return { prefix: "", rest: "" };
   }
-  return lines.join("\n");
-}
-function formatActiveMcpCatalogsForPrompt(catalogs) {
-  if (catalogs.length === 0) {
-    return null;
+  if (fitsInlineBudget(normalized, maxChars, maxLines)) {
+    return { prefix: normalized, rest: "" };
   }
-  const lines = [
-    "Active MCP provider catalogs are available through `searchMcpTools`. Call it with provider to list descriptors or with query to narrow results, then pass the exact returned `tool_name` to `callMcpTool`. Put provider fields inside `arguments`."
-  ];
-  for (const catalog of catalogs) {
-    lines.push("  <catalog>");
-    lines.push(`    <provider>${escapeXml(catalog.provider)}</provider>`);
-    lines.push(
-      `    <available_tool_count>${catalog.available_tool_count}</available_tool_count>`
-    );
-    lines.push("  </catalog>");
+  const lineBounded = splitByLineBudget(normalized, maxLines);
+  const cutIndex = findSplitIndex(lineBounded, maxChars);
+  const prefix = lineBounded.slice(0, cutIndex).trimEnd();
+  if (prefix) {
+    return {
+      prefix,
+      rest: normalized.slice(prefix.length).trimStart()
+    };
   }
-  return lines.join("\n");
+  const hardPrefix = normalized.slice(0, Math.max(1, maxChars)).trimEnd();
+  return {
+    prefix: hardPrefix || normalized.slice(0, Math.max(1, maxChars)),
+    rest: normalized.slice(hardPrefix.length || Math.max(1, maxChars)).trimStart()
+  };
 }
-function formatToolGuidanceForPrompt(tools) {
-  const guidedTools = tools.filter(
-    (tool2) => Boolean(tool2.promptSnippet?.trim()) || (tool2.promptGuidelines?.length ?? 0) > 0
-  );
-  if (guidedTools.length === 0) {
-    return null;
+function splitSlackReplyText(text, options) {
+  const normalized = renderSlackMrkdwn(text);
+  if (!normalized) {
+    return [];
   }
-  const lines = [];
-  for (const tool2 of guidedTools) {
-    lines.push(`  <tool name="${escapeXml(tool2.name)}">`);
-    if (tool2.promptSnippet?.trim()) {
-      lines.push(`    - ${escapeXml(tool2.promptSnippet.trim())}`);
+  const chunks = [];
+  const continuationBudget = reserveInlineBudgetForSuffix(CONTINUED_MARKER);
+  let remaining = normalized;
+  while (remaining) {
+    const fitsFinalChunk = options?.interrupted ? fitsInlineBudget(appendSlackSuffix(remaining, getInterruptionMarker())) : fitsInlineBudget(remaining);
+    if (fitsFinalChunk) {
+      chunks.push(
+        options?.interrupted ? appendSlackSuffix(remaining, getInterruptionMarker()) : remaining
+      );
+      break;
     }
-    if (tool2.promptGuidelines && tool2.promptGuidelines.length > 0) {
-      for (const guideline of tool2.promptGuidelines) {
-        lines.push(`    - ${escapeXml(guideline)}`);
+    const { renderedPrefix, rest } = takeSlackContinuationPrefix(remaining, {
+      ...continuationBudget,
+      forceSplit: true
+    });
+    chunks.push(renderedPrefix);
+    remaining = rest;
+  }
+  if (chunks.length === 2) {
+    chunks[0] = stripTrailingContinuationMarker(chunks[0] ?? "");
+  }
+  return chunks;
+}
+function getSlackContinuationBudget() {
+  return reserveInlineBudgetForSuffix(CONTINUED_MARKER);
+}
+function buildSlackOutputMessage(text, files) {
+  const normalized = renderSlackMrkdwn(text);
+  const fileCount = files?.length ?? 0;
+  if (!normalized) {
+    if (fileCount > 0) {
+      return {
+        raw: "",
+        files
+      };
+    }
+    throw new Error(
+      `Slack output normalized to empty content: original_length=${text.length} parsed_length=${normalized.length}`
+    );
+  }
+  return {
+    markdown: normalized,
+    files
+  };
+}
+var slackOutputPolicy = {
+  maxInlineChars: MAX_INLINE_CHARS,
+  maxInlineLines: MAX_INLINE_LINES
+};
+
+// src/chat/prompt.ts
+var DEFAULT_SOUL = "You are Junior, a practical and concise assistant.";
+function getLoggedMarkdownFiles() {
+  const globalState = globalThis;
+  globalState.__juniorLoggedMarkdownFiles ??= /* @__PURE__ */ new Set();
+  return globalState.__juniorLoggedMarkdownFiles;
+}
+function loadOptionalMarkdownFile(candidates, fileName) {
+  for (const resolved of candidates) {
+    try {
+      const raw = fs.readFileSync(resolved, "utf8").trim();
+      if (raw.length > 0) {
+        const loggedMarkdownFiles = getLoggedMarkdownFiles();
+        const logKey = `${fileName}:${resolved}`;
+        if (!loggedMarkdownFiles.has(logKey)) {
+          loggedMarkdownFiles.add(logKey);
+          logInfo(
+            `${fileName.toLowerCase()}_loaded`,
+            {},
+            {
+              "file.path": resolved
+            },
+            `Loaded ${fileName}`
+          );
+        }
+        return raw;
       }
+    } catch {
+      continue;
     }
-    lines.push("  </tool>");
   }
-  return lines.join("\n");
+  return null;
 }
-function formatReferenceFilesLines() {
-  const files = listReferenceFiles();
-  if (files.length === 0) {
-    return null;
+function loadSoul() {
+  const soul = loadOptionalMarkdownFile(soulPathCandidates(), "SOUL.md");
+  if (soul) {
+    return soul;
   }
-  return files.map((filePath) => {
-    const name = path2.basename(filePath);
-    return `- ${escapeXml(name)} (${escapeXml(`${SANDBOX_DATA_ROOT}/${name}`)})`;
-  });
+  logWarn(
+    "soul_load_fallback",
+    {},
+    {
+      "app.file.candidates": soulPathCandidates()
+    },
+    "SOUL.md not found; using built-in default personality"
+  );
+  return DEFAULT_SOUL;
 }
-function formatArtifactsLines(artifactState) {
-  if (!artifactState) return null;
-  const lines = [];
-  if (artifactState.lastCanvasId) {
-    lines.push(`- last_canvas_id: ${escapeXml(artifactState.lastCanvasId)}`);
+function loadWorld() {
+  return loadOptionalMarkdownFile(worldPathCandidates(), "WORLD.md");
+}
+var JUNIOR_PERSONALITY = (() => {
+  try {
+    return loadSoul();
+  } catch (error) {
+    logWarn(
+      "soul_load_failed",
+      {},
+      {
+        "exception.message": error instanceof Error ? error.message : String(error)
+      },
+      "Failed to load SOUL.md; using built-in default personality"
+    );
+    return DEFAULT_SOUL;
   }
-  if (artifactState.lastCanvasUrl) {
-    lines.push(`- last_canvas_url: ${escapeXml(artifactState.lastCanvasUrl)}`);
+})();
+var JUNIOR_WORLD = (() => {
+  try {
+    return loadWorld();
+  } catch (error) {
+    logWarn(
+      "world_load_failed",
+      {},
+      {
+        "exception.message": error instanceof Error ? error.message : String(error)
+      },
+      "Failed to load WORLD.md; omitting world prompt context"
+    );
+    return null;
   }
-  if (artifactState.recentCanvases && artifactState.recentCanvases.length > 0) {
-    lines.push("- recent_canvases:");
-    for (const canvas of artifactState.recentCanvases) {
-      lines.push(`  - id: ${escapeXml(canvas.id)}`);
-      if (canvas.title) lines.push(`    title: ${escapeXml(canvas.title)}`);
-      if (canvas.url) lines.push(`    url: ${escapeXml(canvas.url)}`);
-      if (canvas.createdAt) {
-        lines.push(`    created_at: ${escapeXml(canvas.createdAt)}`);
-      }
-    }
+})();
+function workspaceSkillDir(skillName) {
+  return sandboxSkillDir(skillName);
+}
+function formatConfigurationValue(value) {
+  if (typeof value === "string") {
+    return escapeXml(value);
   }
-  if (artifactState.lastListId) {
-    lines.push(`- last_list_id: ${escapeXml(artifactState.lastListId)}`);
+  try {
+    return escapeXml(JSON.stringify(value));
+  } catch {
+    return escapeXml(String(value));
   }
-  if (artifactState.lastListUrl) {
-    lines.push(`- last_list_url: ${escapeXml(artifactState.lastListUrl)}`);
+}
+function renderRequesterBlock(fields) {
+  const lines = Object.entries(fields).filter(([, value]) => Boolean(value)).map(([key, value]) => `- ${key}: ${escapeXml(value)}`);
+  if (lines.length === 0) {
+    return null;
   }
-  return lines.length > 0 ? lines : null;
+  return ["<requester>", ...lines, "</requester>"];
 }
-function formatConfigurationLines(configuration) {
-  const keys = Object.keys(configuration ?? {}).sort(
-    (a, b) => a.localeCompare(b)
-  );
-  if (keys.length === 0) return null;
-  return keys.map(
-    (key) => `- ${escapeXml(key)}: ${formatConfigurationValue(configuration?.[key])}`
+function renderTag(tag, lines) {
+  return [`<${tag}>`, ...lines, `</${tag}>`];
+}
+function renderTagBlock(tag, content) {
+  return [`<${tag}>`, content, `</${tag}>`].join("\n");
+}
+function formatSkillEntry(skill) {
+  const skillLocation = `${workspaceSkillDir(skill.name)}/SKILL.md`;
+  const lines = [];
+  lines.push("  <skill>");
+  lines.push(`    <name>${escapeXml(skill.name)}</name>`);
+  lines.push(`    <description>${escapeXml(skill.description)}</description>`);
+  lines.push(`    <location>${escapeXml(skillLocation)}</location>`);
+  if (skill.pluginProvider) {
+    lines.push(`    <provider>${escapeXml(skill.pluginProvider)}</provider>`);
+  }
+  lines.push("  </skill>");
+  return lines;
+}
+function formatAvailableSkillsForPrompt(skills, invocation) {
+  const autoSelectable = skills.filter(
+    (s) => s.disableModelInvocation !== true
   );
+  const invokedExplicitOnly = invocation ? skills.filter(
+    (s) => s.disableModelInvocation === true && s.name === invocation.skillName
+  ) : [];
+  const sections = [];
+  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));
+    }
+    available.push("</available-skills>");
+    sections.push(available.join("\n"));
+  }
+  if (invokedExplicitOnly.length > 0) {
+    const userCallable = [
+      "<user-callable-skills>",
+      "The user's current message explicitly references this skill by name. Load it when relevant to the request."
+    ];
+    for (const skill of invokedExplicitOnly) {
+      userCallable.push(...formatSkillEntry(skill));
+    }
+    userCallable.push("</user-callable-skills>");
+    sections.push(userCallable.join("\n"));
+  }
+  return sections.length > 0 ? sections.join("\n") : null;
 }
-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";
+function formatLoadedSkillsForPrompt(skills) {
+  if (skills.length === 0) {
+    return null;
+  }
+  const lines = ["<loaded-skills>"];
+  for (const skill of skills) {
+    const skillDir = workspaceSkillDir(skill.name);
+    lines.push(
+      `  <skill name="${escapeXml(skill.name)}" location="${escapeXml(`${skillDir}/SKILL.md`)}">`
+    );
+    lines.push(
+      `Skill directory: ${escapeXml(skillDir)}. Resolve relative paths there; for skill-owned bash commands, cd there first or use absolute paths.`
+    );
+    lines.push("");
+    lines.push(skill.body);
+    lines.push("  </skill>");
+  }
+  lines.push("</loaded-skills>");
+  return lines.join("\n");
 }
-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 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.",
+function formatProviderCatalogForPrompt() {
+  const providers = getPluginProviders().map((plugin) => plugin.manifest);
+  if (providers.length === 0) {
+    return null;
+  }
+  const lines = [
+    "Config keys and default targets per provider; use after a skill is loaded. Run authenticated provider commands directly after resolving target defaults; let the runtime handle auth pauses/resumes."
+  ];
+  for (const provider of providers) {
+    lines.push(`- provider: ${escapeXml(provider.name)}`);
+    lines.push(
+      `  - config_keys: ${provider.configKeys.length > 0 ? escapeXml(provider.configKeys.join(", ")) : "none"}`
+    );
+    lines.push(
+      `  - default_context: ${provider.target ? escapeXml(
+        `${provider.target.type} via ${provider.target.configKey}`
+      ) : "none"}`
+    );
+  }
+  return lines.join("\n");
+}
+function formatActiveMcpCatalogsForPrompt(catalogs) {
+  if (catalogs.length === 0) {
+    return null;
+  }
+  const lines = [
+    "Active MCP provider catalogs are available through `searchMcpTools`. Call it with provider to list descriptors or with query to narrow results, then pass the exact returned `tool_name` to `callMcpTool`. Put provider fields inside `arguments`."
+  ];
+  for (const catalog of catalogs) {
+    lines.push("  <catalog>");
+    lines.push(`    <provider>${escapeXml(catalog.provider)}</provider>`);
+    lines.push(
+      `    <available_tool_count>${catalog.available_tool_count}</available_tool_count>`
+    );
+    lines.push("  </catalog>");
+  }
+  return lines.join("\n");
+}
+function formatToolGuidanceForPrompt(tools) {
+  const guidedTools = tools.filter(
+    (tool2) => Boolean(tool2.promptSnippet?.trim()) || (tool2.promptGuidelines?.length ?? 0) > 0
+  );
+  if (guidedTools.length === 0) {
+    return null;
+  }
+  const lines = [];
+  for (const tool2 of guidedTools) {
+    lines.push(`  <tool name="${escapeXml(tool2.name)}">`);
+    if (tool2.promptSnippet?.trim()) {
+      lines.push(`    - ${escapeXml(tool2.promptSnippet.trim())}`);
+    }
+    if (tool2.promptGuidelines && tool2.promptGuidelines.length > 0) {
+      for (const guideline of tool2.promptGuidelines) {
+        lines.push(`    - ${escapeXml(guideline)}`);
+      }
+    }
+    lines.push("  </tool>");
+  }
+  return lines.join("\n");
+}
+function formatReferenceFilesLines() {
+  const files = listReferenceFiles();
+  if (files.length === 0) {
+    return null;
+  }
+  return files.map((filePath) => {
+    const name = path2.basename(filePath);
+    return `- ${escapeXml(name)} (${escapeXml(`${SANDBOX_DATA_ROOT}/${name}`)})`;
+  });
+}
+function formatArtifactsLines(artifactState) {
+  if (!artifactState) return null;
+  const lines = [];
+  if (artifactState.lastCanvasId) {
+    lines.push(`- last_canvas_id: ${escapeXml(artifactState.lastCanvasId)}`);
+  }
+  if (artifactState.lastCanvasUrl) {
+    lines.push(`- last_canvas_url: ${escapeXml(artifactState.lastCanvasUrl)}`);
+  }
+  if (artifactState.recentCanvases && artifactState.recentCanvases.length > 0) {
+    lines.push("- recent_canvases:");
+    for (const canvas of artifactState.recentCanvases) {
+      lines.push(`  - id: ${escapeXml(canvas.id)}`);
+      if (canvas.title) lines.push(`    title: ${escapeXml(canvas.title)}`);
+      if (canvas.url) lines.push(`    url: ${escapeXml(canvas.url)}`);
+      if (canvas.createdAt) {
+        lines.push(`    created_at: ${escapeXml(canvas.createdAt)}`);
+      }
+    }
+  }
+  if (artifactState.lastListId) {
+    lines.push(`- last_list_id: ${escapeXml(artifactState.lastListId)}`);
+  }
+  if (artifactState.lastListUrl) {
+    lines.push(`- last_list_url: ${escapeXml(artifactState.lastListUrl)}`);
+  }
+  return lines.length > 0 ? lines : null;
+}
+function formatConfigurationLines(configuration) {
+  const keys = Object.keys(configuration ?? {}).sort(
+    (a, b) => a.localeCompare(b)
+  );
+  if (keys.length === 0) return null;
+  return keys.map(
+    (key) => `- ${escapeXml(key)}: ${formatConfigurationValue(configuration?.[key])}`
+  );
+}
+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 TOOL_POLICY_RULES = [
+  "- Tool schemas are the source of truth for parameters; tool names are case-sensitive, so call tools exactly by their exposed names and do not invent arguments.",
+  "- Use tools for actionable work and for facts that are mutable, external, repository-backed, provider-backed, or requested as verified/current. Stable general knowledge and already-provided context may be answered directly.",
   "- Resolve provider action targets before calls: explicit target wins; ambient `<configuration>` fills omitted targets. Treat non-target links/references as context.",
   "- Verification source order: conversation/thread context; user-provided attachments, links, and reference files; local/sandbox files when present; loaded skill references; repository/provider tools; public web. Use the nearest authoritative available source before weaker sources.",
   "- For repository or implementation questions, inspect the target repository first: local checkout when present, otherwise the configured GitHub/source provider. Do not treat loaded skill files as repo source unless the user asks about the skill. Cite file paths, symbols, PRs/issues, commits, or URLs that support the answer.",
@@ -3118,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) {
@@ -3180,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
   );
@@ -3202,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 = [
@@ -3235,7 +3651,7 @@ function buildTurnContextPrompt(params) {
     }),
     buildRuntimeSection(params.runtime ?? {}),
     `</${TURN_CONTEXT_TAG}>`
-  ];
+  ].filter((section) => Boolean(section));
   return sections.join("\n\n");
 }
 
@@ -3949,6 +4365,8 @@ var PluginMcpClient = class {
     this.plugin = plugin;
     this.options = options;
   }
+  plugin;
+  options;
   client;
   lastAttemptedTransportSessionId;
   transport;
@@ -4230,6 +4648,7 @@ var McpToolManager = class {
       }
     }
   }
+  options;
   pluginsByProvider = /* @__PURE__ */ new Map();
   activeProviders = /* @__PURE__ */ new Set();
   authorizationPendingProviders = /* @__PURE__ */ new Set();
@@ -7887,7 +8306,7 @@ 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
@@ -7972,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");
@@ -8161,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);
 }
@@ -9137,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",
@@ -9222,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 sharedInternal = process.env.JUNIOR_INTERNAL_RESUME_SECRET?.trim();
-  if (sharedInternal) {
-    return sharedInternal;
+  const secret = process.env.JUNIOR_SECRET?.trim();
+  if (secret) {
+    return secret;
   }
-  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");
@@ -9247,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);
@@ -11249,500 +11639,161 @@ function createSandboxExecutor(options) {
       referenceFiles = [...files];
       sessionManager.configureReferenceFiles(files);
     },
-    getSandboxId() {
-      return sessionManager.getSandboxId();
-    },
-    getDependencyProfileHash() {
-      return sessionManager.getDependencyProfileHash();
-    },
-    canExecute(toolName) {
-      return SANDBOX_TOOL_NAMES.has(toolName);
-    },
-    async createSandbox() {
-      return await sessionManager.createSandbox();
-    },
-    execute,
-    async dispose() {
-      await sessionManager.dispose();
-    }
-  };
-}
-
-// src/chat/runtime/dev-agent-trace.ts
-function shouldEmitDevAgentTrace() {
-  return process.env.NODE_ENV === "development";
-}
-
-// src/chat/services/auth-pause.ts
-var AuthorizationPauseError = class extends Error {
-  disposition;
-  kind;
-  provider;
-  constructor(kind, provider, disposition) {
-    super(
-      kind === "mcp" ? `MCP authorization started for ${provider}` : `Plugin authorization started for ${provider}`
-    );
-    this.name = kind === "mcp" ? "McpAuthorizationPauseError" : "PluginAuthorizationPauseError";
-    this.disposition = disposition;
-    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
-import { THREAD_STATE_TTL_MS as THREAD_STATE_TTL_MS3 } from "chat";
-
-// src/chat/state/pi-session-message-store.ts
-import { isDeepStrictEqual } from "util";
-var PI_SESSION_MESSAGE_PREFIX = "junior:pi_session_message";
-function piSessionMessageKey(scope, index) {
-  return `${PI_SESSION_MESSAGE_PREFIX}:${scope.conversationId}:${scope.sessionId}:${index}`;
-}
-function parsePiMessage(value) {
-  return isRecord(value) ? value : void 0;
-}
-function normalizeMessageCount(value) {
-  return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
-}
-function countMatchingPrefix(left, right) {
-  const limit = Math.min(left.length, right.length);
-  for (let index = 0; index < limit; index += 1) {
-    if (!isDeepStrictEqual(left[index], right[index])) {
-      return index;
-    }
-  }
-  return limit;
-}
-async function loadPiSessionMessages(args) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const messageCount = normalizeMessageCount(args.messageCount);
-  if (messageCount === 0) {
-    return [];
-  }
-  const values = await Promise.all(
-    Array.from(
-      { length: messageCount },
-      (_, index) => stateAdapter.get(piSessionMessageKey(args, index))
-    )
-  );
-  const messages = [];
-  for (const value of values) {
-    const message = parsePiMessage(value);
-    if (!message) {
-      break;
-    }
-    messages.push(message);
-  }
-  return messages.length === messageCount ? messages : void 0;
-}
-async function loadExistingPiSessionMessages(scope, maxCount) {
-  const count = normalizeMessageCount(maxCount);
-  if (count === 0) {
-    return [];
-  }
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const values = await Promise.all(
-    Array.from(
-      { length: count },
-      (_, index) => stateAdapter.get(piSessionMessageKey(scope, index))
-    )
-  );
-  const messages = [];
-  for (const value of values) {
-    const message = parsePiMessage(value);
-    if (!message) {
-      break;
-    }
-    messages.push(message);
-  }
-  return messages;
-}
-async function commitPiSessionMessages(args) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const existingMessages = await loadExistingPiSessionMessages(
-    { conversationId: args.conversationId, sessionId: args.sessionId },
-    args.messages.length
-  );
-  const writeFromIndex = countMatchingPrefix(existingMessages, args.messages);
-  await Promise.all(
-    args.messages.slice(writeFromIndex).map(
-      (message, offset) => stateAdapter.set(
-        piSessionMessageKey(args, writeFromIndex + offset),
-        message,
-        args.ttlMs
-      )
-    )
-  );
-}
-
-// src/chat/state/turn-session-store.ts
-var AGENT_TURN_SESSION_PREFIX = "junior:agent_turn_session";
-var AGENT_TURN_SESSION_TTL_MS = THREAD_STATE_TTL_MS3;
-function agentTurnSessionKey(conversationId, sessionId) {
-  return `${AGENT_TURN_SESSION_PREFIX}:${conversationId}:${sessionId}`;
-}
-function toFiniteNonNegativeNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : void 0;
-}
-function parseAgentTurnUsage(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const usage = {};
-  for (const field of [
-    "inputTokens",
-    "outputTokens",
-    "cachedInputTokens",
-    "cacheCreationTokens",
-    "totalTokens"
-  ]) {
-    const count = toFiniteNonNegativeNumber(value[field]);
-    if (count !== void 0) {
-      usage[field] = count;
-    }
-  }
-  return Object.keys(usage).length > 0 ? usage : void 0;
-}
-function parseStoredRecord(value) {
-  if (isRecord(value)) {
-    return value;
-  }
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  try {
-    const parsed = JSON.parse(value);
-    return isRecord(parsed) ? parsed : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function parseAgentTurnSessionRecord(value) {
-  const parsed = parseStoredRecord(value);
-  if (!parsed) {
-    return void 0;
-  }
-  const status = parsed.state;
-  if (status !== "running" && status !== "awaiting_resume" && status !== "completed" && status !== "failed" && status !== "superseded") {
-    return void 0;
-  }
-  const conversationId = parsed.conversationId;
-  const sessionId = parsed.sessionId;
-  const sliceId = parsed.sliceId;
-  const checkpointVersion = parsed.checkpointVersion;
-  const updatedAtMs = parsed.updatedAtMs;
-  const cumulativeDurationMs = toFiniteNonNegativeNumber(
-    parsed.cumulativeDurationMs
-  );
-  const cumulativeUsage = parseAgentTurnUsage(parsed.cumulativeUsage);
-  if (typeof conversationId !== "string" || typeof sessionId !== "string" || typeof sliceId !== "number" || typeof checkpointVersion !== "number" || typeof updatedAtMs !== "number") {
-    return void 0;
-  }
-  const legacyPiMessages = Array.isArray(parsed.piMessages) ? parsed.piMessages : [];
-  const messageCount = toFiniteNonNegativeNumber(parsed.messageCount) ?? legacyPiMessages.length;
-  return {
-    legacyPiMessages,
-    record: {
-      checkpointVersion,
-      conversationId,
-      sessionId,
-      sliceId,
-      state: status,
-      updatedAtMs,
-      messageCount,
-      ...cumulativeDurationMs !== void 0 ? { cumulativeDurationMs } : {},
-      ...cumulativeUsage ? { cumulativeUsage } : {},
-      ...Array.isArray(parsed.loadedSkillNames) ? {
-        loadedSkillNames: parsed.loadedSkillNames.filter(
-          (value2) => typeof value2 === "string"
-        )
-      } : {},
-      ...parsed.resumeReason === "timeout" || parsed.resumeReason === "auth" ? { resumeReason: parsed.resumeReason } : {},
-      ...typeof parsed.errorMessage === "string" ? { errorMessage: parsed.errorMessage } : {},
-      ...typeof parsed.resumedFromSliceId === "number" ? { resumedFromSliceId: parsed.resumedFromSliceId } : {}
-    }
-  };
-}
-function materializePiMessages(legacyPiMessages, messageCount, sessionMessages) {
-  if (messageCount === 0) {
-    return [];
-  }
-  if (sessionMessages) {
-    return sessionMessages;
-  }
-  if (legacyPiMessages.length >= messageCount) {
-    return legacyPiMessages.slice(0, messageCount);
-  }
-  return void 0;
-}
-async function getAgentTurnSessionCheckpoint(conversationId, sessionId) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const value = await stateAdapter.get(
-    agentTurnSessionKey(conversationId, sessionId)
-  );
-  const parsed = parseAgentTurnSessionRecord(value);
-  if (!parsed) {
-    return void 0;
-  }
-  const sessionMessages = await loadPiSessionMessages({
-    conversationId,
-    sessionId,
-    messageCount: parsed.record.messageCount
-  });
-  const piMessages = materializePiMessages(
-    parsed.legacyPiMessages,
-    parsed.record.messageCount,
-    sessionMessages
-  );
-  if (!piMessages) {
-    return void 0;
-  }
-  return {
-    ...parsed.record,
-    piMessages
-  };
-}
-async function upsertAgentTurnSessionCheckpoint(args) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const existingValue = await stateAdapter.get(
-    agentTurnSessionKey(args.conversationId, args.sessionId)
-  );
-  const existingRecord = parseAgentTurnSessionRecord(existingValue);
-  const ttlMs = Math.max(1, args.ttlMs ?? AGENT_TURN_SESSION_TTL_MS);
-  await commitPiSessionMessages({
-    conversationId: args.conversationId,
-    sessionId: args.sessionId,
-    messages: args.piMessages,
-    ttlMs
-  });
-  const storedMessageCount = args.piMessages.length;
-  const checkpoint = {
-    checkpointVersion: (existingRecord?.record.checkpointVersion ?? 0) + 1,
-    conversationId: args.conversationId,
-    sessionId: args.sessionId,
-    sliceId: args.sliceId,
-    state: args.state,
-    updatedAtMs: Date.now(),
-    messageCount: storedMessageCount,
-    ...typeof args.cumulativeDurationMs === "number" && Number.isFinite(args.cumulativeDurationMs) ? {
-      cumulativeDurationMs: Math.max(
-        0,
-        Math.floor(args.cumulativeDurationMs)
-      )
-    } : {},
-    ...args.cumulativeUsage ? { cumulativeUsage: args.cumulativeUsage } : {},
-    ...Array.isArray(args.loadedSkillNames) ? {
-      loadedSkillNames: args.loadedSkillNames.filter(
-        (value) => typeof value === "string"
-      )
-    } : {},
-    ...args.resumeReason ? { resumeReason: args.resumeReason } : {},
-    ...args.errorMessage ? { errorMessage: args.errorMessage } : {},
-    ...typeof args.resumedFromSliceId === "number" ? { resumedFromSliceId: args.resumedFromSliceId } : {}
-  };
-  await stateAdapter.set(
-    agentTurnSessionKey(args.conversationId, args.sessionId),
-    checkpoint,
-    ttlMs
-  );
-  return {
-    ...checkpoint,
-    piMessages: [...args.piMessages]
+    getSandboxId() {
+      return sessionManager.getSandboxId();
+    },
+    getDependencyProfileHash() {
+      return sessionManager.getDependencyProfileHash();
+    },
+    canExecute(toolName) {
+      return SANDBOX_TOOL_NAMES.has(toolName);
+    },
+    async createSandbox() {
+      return await sessionManager.createSandbox();
+    },
+    execute,
+    async dispose() {
+      await sessionManager.dispose();
+    }
   };
 }
-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/runtime/dev-agent-trace.ts
+function shouldEmitDevAgentTrace() {
+  return process.env.NODE_ENV === "development";
 }
 
-// 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/services/auth-pause.ts
+var AuthorizationPauseError = class extends Error {
+  disposition;
+  kind;
+  provider;
+  constructor(kind, provider, disposition) {
+    super(
+      kind === "mcp" ? `MCP authorization started for ${provider}` : `Plugin authorization started for ${provider}`
+    );
+    this.name = kind === "mcp" ? "McpAuthorizationPauseError" : "PluginAuthorizationPauseError";
+    this.disposition = disposition;
+    this.kind = kind;
+    this.provider = provider;
   }
-  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) {
+};
+
+// src/chat/runtime/report-progress.ts
+function buildReportedProgressStatus(input) {
+  if (!input || typeof input !== "object") {
     return void 0;
   }
-  if (pendingAuth.kind !== args.kind || pendingAuth.provider !== args.provider || pendingAuth.requesterId !== args.requesterId) {
+  const message = input.message;
+  if (typeof message !== "string") {
     return void 0;
   }
-  return pendingAuth;
+  const text = message.trim();
+  if (!text) {
+    return void 0;
+  }
+  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
@@ -12257,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",
       {
@@ -12276,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;
@@ -12334,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;
@@ -12737,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,
@@ -12768,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;
@@ -12907,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) {
@@ -13204,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,
@@ -13393,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,
@@ -13545,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();
           }
         },
         {
@@ -13682,7 +13788,7 @@ async function generateAssistantReply(messageText, context = {}) {
           beforeMessageCount
         );
       }
-      const nextSliceId = await persistAuthPauseCheckpoint({
+      const checkpoint = await persistAuthPauseCheckpoint({
         conversationId: timeoutResumeConversationId,
         sessionId: timeoutResumeSessionId,
         currentSliceId: timeoutResumeSliceId,
@@ -13693,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;
@@ -14923,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);
   }
@@ -14944,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(
@@ -14985,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(
@@ -14998,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);
@@ -15026,7 +15155,7 @@ async function resumeSlackTurn(args) {
           error,
           eventName: "slack_resume_turn_failed",
           lockKey,
-          resumeArgs: args
+          resumeArgs: runArgs
         });
       };
     }
@@ -15034,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;
@@ -15057,7 +15196,7 @@ async function resumeSlackTurn(args) {
         error: pauseError,
         eventName: "slack_resume_pause_handler_failed",
         lockKey,
-        resumeArgs: args
+        resumeArgs: runArgs
       });
       return;
     }
@@ -15080,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
   });
 }
@@ -15114,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";
@@ -15137,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");
@@ -15182,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);
@@ -15280,54 +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 userMessage = getTurnUserMessage(conversation, sessionId);
-  clearPendingAuth(conversation, sessionId);
-  markConversationMessage(conversation, userMessage?.id, {
-    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
-    }
-  });
-  markTurnCompleted({
+  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);
@@ -15341,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
   });
@@ -15353,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",
@@ -15379,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
+          });
+        }
+      };
     }
   });
 }
@@ -15703,52 +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
-    }
-  });
-  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);
@@ -15761,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
   });
@@ -15786,7 +15954,6 @@ async function resumeCheckpointedOAuthTurn(stored) {
     stored.resumeConversationId
   );
   const conversation = coerceThreadConversationState(currentState);
-  const artifacts = coerceThreadArtifactsState(currentState);
   const pendingAuth = getConversationPendingAuth({
     conversation,
     kind: "plugin",
@@ -15817,104 +15984,165 @@ 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"
+    return false;
+  }
+  await resumeSlackTurn({
+    messageText: stored.pendingMessage ?? userMessage.text,
+    channelId: stored.channelId,
+    threadTs: stored.threadTs,
+    messageTs: getTurnUserSlackMessageTs(userMessage),
+    lockKey: stored.resumeConversationId,
+    initialText: "",
+    beforeStart: async () => {
+      const lockedCheckpoint = await getAgentTurnSessionCheckpoint(
+        stored.resumeConversationId,
+        stored.resumeSessionId
       );
-      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
+      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;
@@ -16670,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) {
@@ -16679,42 +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
-    }
-  });
-  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);
@@ -16727,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
+          });
+        }
+      };
     }
   });
 }
@@ -16890,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(
@@ -16905,7 +17141,7 @@ async function resumeTimedOutTurnWithLockRetry(payload) {
         },
         "Timeout resume lock was busy; retrying"
       );
-      await sleep3(delayMs);
+      await sleep4(delayMs);
     }
   }
 }
@@ -18777,27 +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
-            }
-          });
           const artifactStatePatch = reply.artifactStatePatch ? { ...reply.artifactStatePatch } : {};
           const reactionPerformed = reply.diagnostics.toolCalls.includes(
             "slackMessageAddReaction"
@@ -18870,20 +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(),
+            reply,
             sessionId: turnId,
-            updateConversationStats
+            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(
@@ -19021,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
             });
@@ -20159,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) => {