@sentry/junior 0.85.0 → 0.87.0

package/dist/{chunk-MHEV3T2Y.js → chunk-B6FQPS7A.js}

@@ -10,7 +10,7 @@ import {
   isSnapshotMissingError,
   resolveRuntimeDependencySnapshot,
   runNonInteractiveCommand
-} from "./chunk-FYPO4K7C.js";
+} from "./chunk-RIB3M6YA.js";
 import {
   pluginTaskId,
   pluginTaskParamsSchema,
@@ -22,15 +22,19 @@ import {
   buildPluginSystemPromptContributions,
   buildSystemPrompt,
   buildTurnContextPrompt,
+  containsNoReplyMarker,
   getAgentTurnSessionRecord,
+  getInterruptionMarker,
+  isNoReplyMarker,
   loadConnectedMcpProviders,
   recordAuthorizationRequested,
   recordMcpProviderConnected,
   recordSubagentEnded,
   recordSubagentStarted,
   recordToolExecutionStarted,
+  stripNoReplyMarker,
   upsertAgentTurnSessionRecord
-} from "./chunk-GY7L6VCT.js";
+} from "./chunk-ACJJJEGG.js";
 import {
   createPluginEmbedder,
   createPluginHookRunner,
@@ -41,14 +45,15 @@ import {
   getPlugins,
   getSlackToolContext,
   resolveChannelCapabilities
-} from "./chunk-UVNV67EC.js";
+} from "./chunk-2NFV5FMB.js";
 import {
   createPluginLogger,
   createPluginState
-} from "./chunk-MTE5NRPJ.js";
+} from "./chunk-BRSQQRG6.js";
 import {
+  getConversationStore,
   getDb
-} from "./chunk-QTTTRBNB.js";
+} from "./chunk-6I6HBOQM.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
@@ -59,7 +64,7 @@ import {
 import {
   acquireActiveLock,
   getStateAdapter
-} from "./chunk-RUB77TGS.js";
+} from "./chunk-GB5DFM4D.js";
 import {
   SlackActionError,
   downloadPrivateSlackFile,
@@ -70,7 +75,7 @@ import {
   normalizeSlackConversationId,
   parseDestination,
   withSlackRetries
-} from "./chunk-C2PSUWK3.js";
+} from "./chunk-GGD6WK6V.js";
 import {
   GEN_AI_PROVIDER_NAME,
   GEN_AI_SERVER_ADDRESS,
@@ -106,7 +111,7 @@ import {
   toObservablePromptPart,
   trimTrailingAssistantMessages,
   upsertActiveSkill
-} from "./chunk-BU2AWPEN.js";
+} from "./chunk-ZU2ALUVQ.js";
 import {
   parseSlackThreadId,
   resolveConversationPrivacy,
@@ -116,7 +121,7 @@ import {
   toGenAiPayloadMetadata,
   toGenAiPayloadTraceAttributes,
   toGenAiTextMetadata
-} from "./chunk-DR75T7J3.js";
+} from "./chunk-L7OHKDOX.js";
 import {
   discoverSkills,
   findSkillByName,
@@ -138,6 +143,7 @@ import {
   listReferenceFiles
 } from "./chunk-6APU57E6.js";
 import {
+  buildTurnFailureResponse,
   extractGenAiUsageAttributes,
   extractGenAiUsageSummary,
   getActiveTraceId,
@@ -650,6 +656,16 @@ var TurnInputCommitLostError = class extends Error {
 function isTurnInputCommitLostError(error) {
   return error instanceof TurnInputCommitLostError;
 }
+var TurnInputDeferredError = class extends Error {
+  code = "turn_input_deferred";
+  constructor(message = "Turn input is deferred until the active resume ends") {
+    super(message);
+    this.name = "TurnInputDeferredError";
+  }
+};
+function isTurnInputDeferredError(error) {
+  return error instanceof TurnInputDeferredError;
+}
 function startActiveTurn(args) {
   args.conversation.processing.activeTurnId = args.nextTurnId;
   args.updateConversationStats(args.conversation);
@@ -679,186 +695,593 @@ function markTurnFailed(args) {
   args.updateConversationStats(args.conversation);
 }
 
-// src/chat/respond.ts
-import { Agent as Agent2 } from "@earendil-works/pi-agent-core";
-import { THREAD_STATE_TTL_MS as THREAD_STATE_TTL_MS4 } from "chat";
-import { z as z4 } from "zod";
-
-// src/chat/capabilities/catalog.ts
-var cachedCatalog;
-function getCapabilityCatalog() {
-  const signature = pluginCatalogRuntime.getSignature();
-  if (cachedCatalog?.signature === signature) return cachedCatalog;
-  const providers = pluginCatalogRuntime.getCapabilityProviders();
-  const capabilityToProvider = /* @__PURE__ */ new Map();
-  for (const provider of providers) {
-    for (const capability of provider.capabilities) {
-      if (capabilityToProvider.has(capability)) {
-        throw new Error(
-          `Duplicate capability registration for "${capability}"`
-        );
+// src/chat/usage.ts
+var COMPONENT_USAGE_FIELDS = [
+  "inputTokens",
+  "outputTokens",
+  "cachedInputTokens",
+  "cacheCreationTokens"
+];
+function hasAgentTurnUsage(usage) {
+  return Boolean(
+    usage && Object.values(usage).some(
+      (value) => typeof value === "number" && Number.isFinite(value)
+    )
+  );
+}
+function getFiniteCount(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : void 0;
+}
+function getComponentTotal(usage) {
+  let total;
+  for (const field of COMPONENT_USAGE_FIELDS) {
+    const value = getFiniteCount(usage[field]);
+    if (value === void 0) continue;
+    total = (total ?? 0) + value;
+  }
+  return total;
+}
+function addAgentTurnUsage(...usages) {
+  const components = {};
+  let componentTotal;
+  let totalOnlyTokens;
+  for (const usage of usages) {
+    if (!usage) continue;
+    const usageComponentTotal = getComponentTotal(usage);
+    if (usageComponentTotal !== void 0) {
+      componentTotal = (componentTotal ?? 0) + usageComponentTotal;
+      for (const field of COMPONENT_USAGE_FIELDS) {
+        const value = getFiniteCount(usage[field]);
+        if (value === void 0) continue;
+        components[field] = (components[field] ?? 0) + value;
       }
-      capabilityToProvider.set(capability, provider);
+      continue;
+    }
+    const totalTokens = getFiniteCount(usage.totalTokens);
+    if (totalTokens !== void 0) {
+      totalOnlyTokens = (totalOnlyTokens ?? 0) + totalTokens;
     }
   }
-  cachedCatalog = { signature, providers, capabilityToProvider };
-  return cachedCatalog;
+  if (totalOnlyTokens !== void 0) {
+    return {
+      totalTokens: totalOnlyTokens + (componentTotal ?? 0)
+    };
+  }
+  return hasAgentTurnUsage(components) ? components : void 0;
 }
-var catalogLogged = false;
-function logCapabilityCatalogLoadedOnce() {
-  if (catalogLogged) return;
-  catalogLogged = true;
-  const { providers } = getCapabilityCatalog();
-  const capabilityNames = providers.flatMap((p) => p.capabilities).sort();
-  const configKeys = [
-    ...new Set(providers.flatMap((p) => p.configKeys))
-  ].sort();
-  logInfo(
-    "capability_catalog_loaded",
-    {},
+
+// src/chat/services/turn-session-record.ts
+var AGENT_CONTINUE_MAX_SLICES = 48;
+function logSessionRecordError(error, eventName, args, attributes, message) {
+  logException(
+    error,
+    eventName,
     {
-      "app.capability.providers": providers.map((p) => p.provider),
-      "app.capability.count": capabilityNames.length,
-      "app.capability.names": capabilityNames,
-      "app.config.key_count": configKeys.length,
-      "app.config.keys": configKeys
+      slackThreadId: args.logContext.threadId,
+      slackUserId: args.logContext.requesterId,
+      slackChannelId: args.logContext.channelId,
+      runId: args.logContext.runId,
+      assistantUserName: args.logContext.assistantUserName,
+      modelId: args.logContext.modelId
     },
-    "Loaded capability provider catalog"
+    {
+      "app.ai.resume_conversation_id": args.conversationId,
+      "app.ai.resume_session_id": args.sessionId,
+      ...attributes
+    },
+    message
   );
 }
-
-// src/chat/capabilities/router.ts
-var ProviderCredentialRouter = class {
-  brokersByProvider;
-  constructor(input) {
-    this.brokersByProvider = input.brokersByProvider;
+function addDurationMs(prior, current) {
+  const total = [prior, current].reduce((sum, value) => {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      return sum;
+    }
+    return (sum ?? 0) + Math.max(0, Math.floor(value));
+  }, void 0);
+  return total;
+}
+function isContinuableBoundary(messages) {
+  const lastRole = getPiMessageRole(messages.at(-1));
+  return lastRole === "user" || lastRole === "toolResult";
+}
+function resumableBoundary(messages, fallbackMessages) {
+  const current = trimTrailingAssistantMessages(messages);
+  if (current.length > 0 && isContinuableBoundary(current)) {
+    return current;
   }
-  async issue(input) {
-    const broker = this.brokersByProvider[input.provider];
-    if (!broker) {
+  return trimTrailingAssistantMessages(fallbackMessages ?? []);
+}
+async function loadTurnSessionRecord(ctx) {
+  const canUseTurnSession = Boolean(ctx.conversationId && ctx.sessionId);
+  const existingSessionRecord = canUseTurnSession && ctx.conversationId && ctx.sessionId ? await getAgentTurnSessionRecord(ctx.conversationId, ctx.sessionId) : void 0;
+  const hasAwaitingResumeRecord = Boolean(
+    existingSessionRecord && existingSessionRecord.state === "awaiting_resume"
+  );
+  return {
+    canUseTurnSession,
+    resumedFromSessionRecord: hasAwaitingResumeRecord,
+    currentSliceId: hasAwaitingResumeRecord ? existingSessionRecord.sliceId : 1,
+    existingSessionRecord
+  };
+}
+async function persistRunningSessionRecord(args) {
+  if (args.messages.length === 0 || !isContinuableBoundary(args.messages)) {
+    return false;
+  }
+  try {
+    const latestSessionRecord = await getAgentTurnSessionRecord(
+      args.conversationId,
+      args.sessionId
+    );
+    await upsertAgentTurnSessionRecord({
+      ...args.channelName ?? latestSessionRecord?.channelName ? { channelName: args.channelName ?? latestSessionRecord?.channelName } : {},
+      conversationId: args.conversationId,
+      cumulativeDurationMs: latestSessionRecord?.cumulativeDurationMs,
+      cumulativeUsage: latestSessionRecord?.cumulativeUsage,
+      ...args.destination ?? latestSessionRecord?.destination ? { destination: args.destination ?? latestSessionRecord?.destination } : {},
+      ...args.source ?? latestSessionRecord?.source ? { source: args.source ?? latestSessionRecord?.source } : {},
+      sessionId: args.sessionId,
+      sliceId: args.sliceId,
+      state: "running",
+      piMessages: args.messages,
+      ...args.surface ?? latestSessionRecord?.surface ? { surface: args.surface ?? latestSessionRecord?.surface } : {},
+      ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
+      ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
+      ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {},
+      ...(args.turnStartMessageIndex ?? latestSessionRecord?.turnStartMessageIndex) !== void 0 ? {
+        turnStartMessageIndex: args.turnStartMessageIndex ?? latestSessionRecord?.turnStartMessageIndex
+      } : {}
+    });
+    return true;
+  } catch (recordError) {
+    logSessionRecordError(
+      recordError,
+      "agent_turn_running_session_record_failed",
+      args,
+      {
+        "app.ai.resume_slice_id": args.sliceId
+      },
+      "Failed to persist running turn session record"
+    );
+    return false;
+  }
+}
+async function persistCompletedSessionRecord(args) {
+  let sliceId = args.sliceId;
+  try {
+    const latestSessionRecord = await getAgentTurnSessionRecord(
+      args.conversationId,
+      args.sessionId
+    );
+    sliceId = sliceId ?? latestSessionRecord?.sliceId;
+    if (sliceId === void 0) {
       throw new Error(
-        `No credential broker registered for provider: ${input.provider}`
+        "Completed session record requires a slice id from the caller or the latest stored record"
       );
     }
-    return await broker.issue({
-      context: input.context,
-      reason: input.reason
+    await upsertAgentTurnSessionRecord({
+      ...args.channelName ?? latestSessionRecord?.channelName ? { channelName: args.channelName ?? latestSessionRecord?.channelName } : {},
+      conversationId: args.conversationId,
+      cumulativeDurationMs: addDurationMs(
+        latestSessionRecord?.cumulativeDurationMs,
+        args.currentDurationMs
+      ),
+      cumulativeUsage: addAgentTurnUsage(
+        latestSessionRecord?.cumulativeUsage,
+        args.currentUsage
+      ),
+      ...args.destination ?? latestSessionRecord?.destination ? { destination: args.destination ?? latestSessionRecord?.destination } : {},
+      ...args.source ?? latestSessionRecord?.source ? { source: args.source ?? latestSessionRecord?.source } : {},
+      ...args.destinationVisibility ? { destinationVisibility: args.destinationVisibility } : {},
+      sessionId: args.sessionId,
+      sliceId,
+      state: "completed",
+      piMessages: args.allMessages,
+      ...args.surface ?? latestSessionRecord?.surface ? { surface: args.surface ?? latestSessionRecord?.surface } : {},
+      ...args.loadedSkillNames ?? latestSessionRecord?.loadedSkillNames ? {
+        loadedSkillNames: args.loadedSkillNames ?? latestSessionRecord?.loadedSkillNames
+      } : {},
+      ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
+      ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {},
+      ...(args.turnStartMessageIndex ?? latestSessionRecord?.turnStartMessageIndex) !== void 0 ? {
+        turnStartMessageIndex: args.turnStartMessageIndex ?? latestSessionRecord?.turnStartMessageIndex
+      } : {}
     });
+  } catch (recordError) {
+    logSessionRecordError(
+      recordError,
+      "agent_turn_completed_session_record_failed",
+      args,
+      sliceId !== void 0 ? { "app.ai.resume_slice_id": sliceId } : {},
+      "Failed to persist completed turn session record"
+    );
   }
-};
-
-// src/chat/credentials/user-token-store.ts
-import {
-  pluginStoredTokensSchema
-} from "@sentry/junior-plugin-api";
-var storedTokensSchema = pluginStoredTokensSchema;
-
-// src/chat/credentials/state-adapter-token-store.ts
-var KEY_PREFIX = "oauth-token";
-var BUFFER_MS = 24 * 60 * 60 * 1e3;
-var LONG_LIVED_TTL_MS = 365 * 24 * 60 * 60 * 1e3;
-var REFRESH_LOCK_WAIT_MS = 3e4;
-var REFRESH_LOCK_RETRY_MS = 100;
-function tokenKey(userId, provider) {
-  return `${KEY_PREFIX}:${userId}:${provider}`;
 }
-function refreshLockKey(userId, provider) {
-  return `${tokenKey(userId, provider)}:refresh`;
+async function completeDeliveredTurn(args) {
+  await persistCompletedSessionRecord({
+    channelName: args.channelName,
+    conversationId: args.conversationId,
+    currentDurationMs: args.durationMs,
+    currentUsage: args.usage,
+    destination: args.destination,
+    destinationVisibility: args.destinationVisibility,
+    source: args.source,
+    sessionId: args.sessionId,
+    sliceId: args.sliceId,
+    allMessages: args.messages,
+    loadedSkillNames: args.loadedSkillNames,
+    logContext: args.logContext,
+    requester: args.requester,
+    surface: args.surface,
+    turnStartMessageIndex: args.turnStartMessageIndex
+  });
 }
-async function sleep(ms) {
-  await new Promise((resolve) => setTimeout(resolve, ms));
-}
-var StateAdapterTokenStore = class {
-  state;
-  constructor(stateAdapter) {
-    this.state = stateAdapter;
-  }
-  async get(userId, provider) {
-    const stored = await this.state.get(tokenKey(userId, provider));
-    return stored === null || stored === void 0 ? void 0 : storedTokensSchema.parse(stored);
-  }
-  async set(userId, provider, tokens) {
-    const parsed = storedTokensSchema.parse(tokens);
-    const expiresAt = parsed.refreshTokenExpiresAt ?? parsed.expiresAt;
-    const ttlMs2 = expiresAt ? Math.max(expiresAt - Date.now() + BUFFER_MS, BUFFER_MS) : LONG_LIVED_TTL_MS;
-    await this.state.set(tokenKey(userId, provider), parsed, ttlMs2);
-  }
-  async delete(userId, provider) {
-    await this.state.delete(tokenKey(userId, provider));
-  }
-  /** Wait for the per-slot refresh gate so rotated refresh tokens are used once. */
-  async withRefresh(userId, provider, callback) {
-    const lockKey = refreshLockKey(userId, provider);
-    const deadline = Date.now() + REFRESH_LOCK_WAIT_MS;
-    while (true) {
-      const lock = await acquireActiveLock(this.state, lockKey);
-      if (lock) {
-        try {
-          return await callback();
-        } finally {
-          await this.state.releaseLock(lock);
-        }
-      }
-      if (Date.now() >= deadline) {
-        throw new Error(`Could not acquire OAuth token refresh lock`);
-      }
-      await sleep(REFRESH_LOCK_RETRY_MS);
+async function persistAuthPauseSessionRecord(args) {
+  const nextSliceId = args.currentSliceId + 1;
+  try {
+    const latestSessionRecord = await getAgentTurnSessionRecord(
+      args.conversationId,
+      args.sessionId
+    );
+    const piMessages = resumableBoundary(
+      args.messages,
+      latestSessionRecord?.piMessages
+    );
+    if (piMessages.length > 0 && !isContinuableBoundary(piMessages)) {
+      return void 0;
     }
+    return await upsertAgentTurnSessionRecord({
+      ...args.channelName ?? latestSessionRecord?.channelName ? { channelName: args.channelName ?? latestSessionRecord?.channelName } : {},
+      conversationId: args.conversationId,
+      cumulativeDurationMs: addDurationMs(
+        latestSessionRecord?.cumulativeDurationMs,
+        args.currentDurationMs
+      ),
+      cumulativeUsage: addAgentTurnUsage(
+        latestSessionRecord?.cumulativeUsage,
+        args.currentUsage
+      ),
+      ...args.destination ?? latestSessionRecord?.destination ? { destination: args.destination ?? latestSessionRecord?.destination } : {},
+      ...args.source ?? latestSessionRecord?.source ? { source: args.source ?? latestSessionRecord?.source } : {},
+      sessionId: args.sessionId,
+      sliceId: nextSliceId,
+      state: "awaiting_resume",
+      piMessages,
+      ...args.surface ?? latestSessionRecord?.surface ? { surface: args.surface ?? latestSessionRecord?.surface } : {},
+      ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
+      resumeReason: "auth",
+      resumedFromSliceId: args.currentSliceId,
+      errorMessage: args.errorMessage,
+      ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
+      ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {}
+    });
+  } catch (recordError) {
+    logSessionRecordError(
+      recordError,
+      "agent_turn_auth_resume_session_record_failed",
+      args,
+      {
+        "app.ai.resume_from_slice_id": args.currentSliceId,
+        "app.ai.resume_next_slice_id": nextSliceId
+      },
+      "Failed to persist auth session record before retry"
+    );
   }
-};
-
-// src/chat/capabilities/factory.ts
-var sandboxEgressRouters = /* @__PURE__ */ new WeakMap();
-function createUserTokenStore() {
-  return new StateAdapterTokenStore(getStateAdapter());
+  return void 0;
 }
-function createProviderCredentialRouter(userTokenStore) {
-  logCapabilityCatalogLoadedOnce();
-  const brokersByProvider = {};
-  for (const plugin of pluginCatalogRuntime.getProviders()) {
-    const { name } = plugin.manifest;
-    if (!plugin.manifest.credentials && !plugin.manifest.apiHeaders) {
-      continue;
+async function persistTimeoutSessionRecord(args) {
+  const nextSliceId = args.currentSliceId + 1;
+  try {
+    const latestSessionRecord = await getAgentTurnSessionRecord(
+      args.conversationId,
+      args.sessionId
+    );
+    const piMessages = resumableBoundary(
+      args.messages,
+      latestSessionRecord?.piMessages
+    );
+    if (piMessages.length === 0 || !isContinuableBoundary(piMessages)) {
+      return void 0;
     }
-    brokersByProvider[name] = pluginCatalogRuntime.createBroker(name, {
-      userTokenStore
+    const cumulativeDurationMs = addDurationMs(
+      latestSessionRecord?.cumulativeDurationMs,
+      args.currentDurationMs
+    );
+    const cumulativeUsage = addAgentTurnUsage(
+      latestSessionRecord?.cumulativeUsage,
+      args.currentUsage
+    );
+    if (nextSliceId > AGENT_CONTINUE_MAX_SLICES) {
+      return await upsertAgentTurnSessionRecord({
+        ...args.channelName ?? latestSessionRecord?.channelName ? {
+          channelName: args.channelName ?? latestSessionRecord?.channelName
+        } : {},
+        conversationId: args.conversationId,
+        cumulativeDurationMs,
+        cumulativeUsage,
+        ...args.destination ?? latestSessionRecord?.destination ? {
+          destination: args.destination ?? latestSessionRecord?.destination
+        } : {},
+        ...args.source ?? latestSessionRecord?.source ? { source: args.source ?? latestSessionRecord?.source } : {},
+        sessionId: args.sessionId,
+        sliceId: args.currentSliceId,
+        state: "failed",
+        piMessages,
+        ...args.surface ?? latestSessionRecord?.surface ? { surface: args.surface ?? latestSessionRecord?.surface } : {},
+        ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
+        resumeReason: "timeout",
+        resumedFromSliceId: latestSessionRecord?.resumedFromSliceId,
+        errorMessage: `Agent continuation exceeded slice limit (${AGENT_CONTINUE_MAX_SLICES})`,
+        ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
+        ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {}
+      });
+    }
+    return await upsertAgentTurnSessionRecord({
+      ...args.channelName ?? latestSessionRecord?.channelName ? { channelName: args.channelName ?? latestSessionRecord?.channelName } : {},
+      conversationId: args.conversationId,
+      cumulativeDurationMs,
+      cumulativeUsage,
+      ...args.destination ?? latestSessionRecord?.destination ? { destination: args.destination ?? latestSessionRecord?.destination } : {},
+      ...args.source ?? latestSessionRecord?.source ? { source: args.source ?? latestSessionRecord?.source } : {},
+      sessionId: args.sessionId,
+      sliceId: nextSliceId,
+      state: "awaiting_resume",
+      piMessages,
+      ...args.surface ?? latestSessionRecord?.surface ? { surface: args.surface ?? latestSessionRecord?.surface } : {},
+      ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
+      resumeReason: "timeout",
+      resumedFromSliceId: args.currentSliceId,
+      errorMessage: args.errorMessage,
+      ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
+      ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {}
     });
+  } catch (recordError) {
+    logSessionRecordError(
+      recordError,
+      "agent_continue_session_record_failed",
+      args,
+      {
+        "app.ai.resume_from_slice_id": args.currentSliceId,
+        "app.ai.resume_next_slice_id": nextSliceId
+      },
+      "Failed to persist session record before scheduling agent continuation"
+    );
+    return void 0;
   }
-  return new ProviderCredentialRouter({ brokersByProvider });
 }
-function getSandboxEgressRouter() {
-  const stateAdapter = getStateAdapter();
-  let router = sandboxEgressRouters.get(stateAdapter);
-  if (!router) {
-    router = createProviderCredentialRouter(
-      new StateAdapterTokenStore(stateAdapter)
+async function persistYieldSessionRecord(args) {
+  try {
+    const latestSessionRecord = await getAgentTurnSessionRecord(
+      args.conversationId,
+      args.sessionId
     );
-    sandboxEgressRouters.set(stateAdapter, router);
+    const piMessages = resumableBoundary(
+      args.messages,
+      latestSessionRecord?.piMessages
+    );
+    if (piMessages.length === 0 || !isContinuableBoundary(piMessages)) {
+      return void 0;
+    }
+    return await upsertAgentTurnSessionRecord({
+      ...args.channelName ?? latestSessionRecord?.channelName ? { channelName: args.channelName ?? latestSessionRecord?.channelName } : {},
+      conversationId: args.conversationId,
+      cumulativeDurationMs: addDurationMs(
+        latestSessionRecord?.cumulativeDurationMs,
+        args.currentDurationMs
+      ),
+      cumulativeUsage: addAgentTurnUsage(
+        latestSessionRecord?.cumulativeUsage,
+        args.currentUsage
+      ),
+      ...args.destination ?? latestSessionRecord?.destination ? { destination: args.destination ?? latestSessionRecord?.destination } : {},
+      ...args.source ?? latestSessionRecord?.source ? { source: args.source ?? latestSessionRecord?.source } : {},
+      sessionId: args.sessionId,
+      sliceId: args.currentSliceId,
+      state: "awaiting_resume",
+      piMessages,
+      ...args.surface ?? latestSessionRecord?.surface ? { surface: args.surface ?? latestSessionRecord?.surface } : {},
+      ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
+      resumeReason: "yield",
+      resumedFromSliceId: latestSessionRecord?.resumedFromSliceId,
+      errorMessage: args.errorMessage,
+      ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
+      ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {}
+    });
+  } catch (recordError) {
+    logSessionRecordError(
+      recordError,
+      "agent_turn_yield_session_record_failed",
+      args,
+      {
+        "app.ai.resume_slice_id": args.currentSliceId
+      },
+      "Failed to persist cooperative yield session record"
+    );
+    return void 0;
   }
-  return router;
-}
-async function issueProviderCredentialLease(input) {
-  return await getSandboxEgressRouter().issue(input);
 }
 
-// src/chat/capabilities/jr-rpc-command.ts
-import { Bash, defineCommand } from "just-bash";
-function commandResult(input) {
-  let stdout = "";
-  if (typeof input.stdout === "string") {
-    stdout = input.stdout;
-  } else if (input.stdout !== void 0) {
-    stdout = `${JSON.stringify(input.stdout, null, 2)}
-`;
-  }
-  return {
-    stdout,
-    stderr: input.stderr ?? "",
-    exitCode: input.exitCode
-  };
-}
-function requireChannelConfiguration(deps) {
-  if (deps.channelConfiguration) {
+// src/chat/respond.ts
+import { Agent as Agent2 } from "@earendil-works/pi-agent-core";
+import { THREAD_STATE_TTL_MS as THREAD_STATE_TTL_MS4 } from "chat";
+import { z as z4 } from "zod";
+
+// src/chat/capabilities/catalog.ts
+var cachedCatalog;
+function getCapabilityCatalog() {
+  const signature = pluginCatalogRuntime.getSignature();
+  if (cachedCatalog?.signature === signature) return cachedCatalog;
+  const providers = pluginCatalogRuntime.getCapabilityProviders();
+  const capabilityToProvider = /* @__PURE__ */ new Map();
+  for (const provider of providers) {
+    for (const capability of provider.capabilities) {
+      if (capabilityToProvider.has(capability)) {
+        throw new Error(
+          `Duplicate capability registration for "${capability}"`
+        );
+      }
+      capabilityToProvider.set(capability, provider);
+    }
+  }
+  cachedCatalog = { signature, providers, capabilityToProvider };
+  return cachedCatalog;
+}
+var catalogLogged = false;
+function logCapabilityCatalogLoadedOnce() {
+  if (catalogLogged) return;
+  catalogLogged = true;
+  const { providers } = getCapabilityCatalog();
+  const capabilityNames = providers.flatMap((p) => p.capabilities).sort();
+  const configKeys = [
+    ...new Set(providers.flatMap((p) => p.configKeys))
+  ].sort();
+  logInfo(
+    "capability_catalog_loaded",
+    {},
+    {
+      "app.capability.providers": providers.map((p) => p.provider),
+      "app.capability.count": capabilityNames.length,
+      "app.capability.names": capabilityNames,
+      "app.config.key_count": configKeys.length,
+      "app.config.keys": configKeys
+    },
+    "Loaded capability provider catalog"
+  );
+}
+
+// src/chat/capabilities/router.ts
+var ProviderCredentialRouter = class {
+  brokersByProvider;
+  constructor(input) {
+    this.brokersByProvider = input.brokersByProvider;
+  }
+  async issue(input) {
+    const broker = this.brokersByProvider[input.provider];
+    if (!broker) {
+      throw new Error(
+        `No credential broker registered for provider: ${input.provider}`
+      );
+    }
+    return await broker.issue({
+      context: input.context,
+      reason: input.reason
+    });
+  }
+};
+
+// src/chat/credentials/user-token-store.ts
+import {
+  pluginStoredTokensSchema
+} from "@sentry/junior-plugin-api";
+var storedTokensSchema = pluginStoredTokensSchema;
+
+// src/chat/credentials/state-adapter-token-store.ts
+var KEY_PREFIX = "oauth-token";
+var BUFFER_MS = 24 * 60 * 60 * 1e3;
+var LONG_LIVED_TTL_MS = 365 * 24 * 60 * 60 * 1e3;
+var REFRESH_LOCK_WAIT_MS = 3e4;
+var REFRESH_LOCK_RETRY_MS = 100;
+function tokenKey(userId, provider) {
+  return `${KEY_PREFIX}:${userId}:${provider}`;
+}
+function refreshLockKey(userId, provider) {
+  return `${tokenKey(userId, provider)}:refresh`;
+}
+async function sleep(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+var StateAdapterTokenStore = class {
+  state;
+  constructor(stateAdapter) {
+    this.state = stateAdapter;
+  }
+  async get(userId, provider) {
+    const stored = await this.state.get(tokenKey(userId, provider));
+    return stored === null || stored === void 0 ? void 0 : storedTokensSchema.parse(stored);
+  }
+  async set(userId, provider, tokens) {
+    const parsed = storedTokensSchema.parse(tokens);
+    const expiresAt = parsed.refreshTokenExpiresAt ?? parsed.expiresAt;
+    const ttlMs2 = expiresAt ? Math.max(expiresAt - Date.now() + BUFFER_MS, BUFFER_MS) : LONG_LIVED_TTL_MS;
+    await this.state.set(tokenKey(userId, provider), parsed, ttlMs2);
+  }
+  async delete(userId, provider) {
+    await this.state.delete(tokenKey(userId, provider));
+  }
+  /** Wait for the per-slot refresh gate so rotated refresh tokens are used once. */
+  async withRefresh(userId, provider, callback) {
+    const lockKey = refreshLockKey(userId, provider);
+    const deadline = Date.now() + REFRESH_LOCK_WAIT_MS;
+    while (true) {
+      const lock = await acquireActiveLock(this.state, lockKey);
+      if (lock) {
+        try {
+          return await callback();
+        } finally {
+          await this.state.releaseLock(lock);
+        }
+      }
+      if (Date.now() >= deadline) {
+        throw new Error(`Could not acquire OAuth token refresh lock`);
+      }
+      await sleep(REFRESH_LOCK_RETRY_MS);
+    }
+  }
+};
+
+// src/chat/capabilities/factory.ts
+var sandboxEgressRouters = /* @__PURE__ */ new WeakMap();
+function createUserTokenStore() {
+  return new StateAdapterTokenStore(getStateAdapter());
+}
+function createProviderCredentialRouter(userTokenStore) {
+  logCapabilityCatalogLoadedOnce();
+  const brokersByProvider = {};
+  for (const plugin of pluginCatalogRuntime.getProviders()) {
+    const { name } = plugin.manifest;
+    if (!plugin.manifest.credentials && !plugin.manifest.apiHeaders) {
+      continue;
+    }
+    brokersByProvider[name] = pluginCatalogRuntime.createBroker(name, {
+      userTokenStore
+    });
+  }
+  return new ProviderCredentialRouter({ brokersByProvider });
+}
+function getSandboxEgressRouter() {
+  const stateAdapter = getStateAdapter();
+  let router = sandboxEgressRouters.get(stateAdapter);
+  if (!router) {
+    router = createProviderCredentialRouter(
+      new StateAdapterTokenStore(stateAdapter)
+    );
+    sandboxEgressRouters.set(stateAdapter, router);
+  }
+  return router;
+}
+async function issueProviderCredentialLease(input) {
+  return await getSandboxEgressRouter().issue(input);
+}
+
+// src/chat/capabilities/jr-rpc-command.ts
+import { Bash, defineCommand } from "just-bash";
+function commandResult(input) {
+  let stdout = "";
+  if (typeof input.stdout === "string") {
+    stdout = input.stdout;
+  } else if (input.stdout !== void 0) {
+    stdout = `${JSON.stringify(input.stdout, null, 2)}
+`;
+  }
+  return {
+    stdout,
+    stderr: input.stderr ?? "",
+    exitCode: input.exitCode
+  };
+}
+function requireChannelConfiguration(deps) {
+  if (deps.channelConfiguration) {
     return { ok: true, configuration: deps.channelConfiguration };
   }
   return {
@@ -4470,6 +4893,7 @@ async function getPermalinkBestEffort(args) {
       3,
       {
         action: "chat.getPermalink",
+        idempotent: true,
         spanAttributes: {
           "app.slack.channel_id": args.channelId,
           "app.slack.message_ts": args.messageTs
@@ -4522,30 +4946,6 @@ async function postSlackMessage(input) {
     } : {}
   };
 }
-async function deleteSlackMessage(input) {
-  const channelId = requireSlackConversationId(
-    input.channelId,
-    "Slack message deletion"
-  );
-  const timestamp = requireSlackMessageTimestamp(
-    input.timestamp,
-    "Slack message deletion"
-  );
-  await withSlackRetries(
-    () => getSlackClient().chat.delete({
-      channel: channelId,
-      ts: timestamp
-    }),
-    3,
-    {
-      action: "chat.delete",
-      spanAttributes: {
-        "app.slack.channel_id": channelId,
-        "app.slack.message_ts": timestamp
-      }
-    }
-  );
-}
 async function postSlackEphemeralMessage(input) {
   const channelId = requireSlackConversationId(
     input.channelId,
@@ -4647,6 +5047,7 @@ async function addReactionToMessage(input) {
       3,
       {
         action: "reactions.add",
+        idempotent: true,
         spanAttributes: {
           "app.slack.channel_id": channelId,
           "app.slack.message_ts": timestamp,
@@ -4685,6 +5086,7 @@ async function removeReactionFromMessage(input) {
       3,
       {
         action: "reactions.remove",
+        idempotent: true,
         spanAttributes: {
           "app.slack.channel_id": channelId,
           "app.slack.message_ts": timestamp,
@@ -4720,7 +5122,7 @@ function createOperationKey(toolName, input) {
 // src/chat/tools/slack/channel-post-message.ts
 function createSlackChannelPostMessageTool(context, state) {
   return tool({
-    description: "Post a new top-level message to the current Slack channel. Use only when the user explicitly asks to post/send/share/say something to the channel. Do not use for thread replies, inline @mentions, or pinging mentioned users.",
+    description: "Post a new top-level message to the current Slack channel. Use only when the user explicitly asks to post/send/share/say something to the current channel. Do not use for other named channels, thread replies, inline @mentions, or pinging mentioned users.",
     inputSchema: Type15.Object({
       text: Type15.String({
         minLength: 1,
@@ -4765,7 +5167,7 @@ function createSlackChannelPostMessageTool(context, state) {
 import { Type as Type16 } from "@sinclair/typebox";
 function createSlackMessageAddReactionTool(context, state) {
   return tool({
-    description: "Add an emoji reaction to the current inbound Slack message. Use sparingly for lightweight acknowledgements. Provide a Slack emoji alias name (for example `thumbsup`, `white_check_mark`, or `thumbsup::skin-tone-6`), not a unicode emoji glyph. The target message is injected by runtime context; do not use this for arbitrary historical messages.",
+    description: "Add an emoji reaction to the current inbound Slack message. Use when the user asks for a reaction on the current message without another target. Provide a Slack emoji alias name (for example `thumbsup`, `white_check_mark`, or `thumbsup::skin-tone-6`), not a unicode emoji glyph. The target message is injected by runtime context; do not use this for arbitrary historical messages.",
     inputSchema: Type16.Object({
       emoji: Type16.String({
         minLength: 1,
@@ -4777,17 +5179,15 @@ function createSlackMessageAddReactionTool(context, state) {
       const targetChannelId = context.sourceChannelId;
       const targetMessageTs = context.messageTs;
       if (!targetMessageTs) {
-        return {
-          ok: false,
-          error: "No active message timestamp is available for reactions"
-        };
+        throw new ToolInputError(
+          "No active message timestamp is available for reactions."
+        );
       }
       const normalizedEmoji = normalizeSlackEmojiName(emoji);
       if (!normalizedEmoji) {
-        return {
-          ok: false,
-          error: "Emoji must be a valid Slack emoji alias name (for example `thumbsup` or `thumbsup::skin-tone-6`)"
-        };
+        throw new ToolInputError(
+          "Emoji must be a valid Slack emoji alias name (for example `thumbsup` or `thumbsup::skin-tone-6`)."
+        );
       }
       const operationKey = createOperationKey("slackMessageAddReaction", {
         channel_id: targetChannelId,
@@ -5750,6 +6150,31 @@ function createSlackListUpdateItemTool(state) {
 // src/chat/tools/slack/thread-read.ts
 import { Type as Type19 } from "@sinclair/typebox";
 
+// src/chat/tools/slack/channel-access.ts
+async function checkSlackChannelReadAccess(args) {
+  const target = normalizeSlackConversationId(args.targetChannelId);
+  if (!target) {
+    return { allowed: false, error: "Invalid Slack channel ID." };
+  }
+  const currentChannels = args.currentChannelIds.map((channelId) => normalizeSlackConversationId(channelId)).filter((channelId) => Boolean(channelId));
+  if (currentChannels.includes(target)) {
+    return { allowed: true };
+  }
+  const store = args.store ?? getConversationStore();
+  const visibility = await store.getDestinationVisibility({
+    provider: "slack",
+    providerTenantId: args.teamId,
+    providerDestinationId: target
+  });
+  if (visibility === "public") {
+    return { allowed: true };
+  }
+  return {
+    allowed: false,
+    error: "Cannot read this Slack conversation: only the current conversation or public channels Junior has seen in this workspace are readable."
+  };
+}
+
 // src/chat/tools/slack/slack-message-url.ts
 var SLACK_HOST_PATTERN = /^[a-z0-9-]+\.slack(?:-gov)?\.com$/;
 var ARCHIVE_PATH_PATTERN = /^\/archives\/([CDG][A-Z0-9]+)\/p(\d{10})(\d{6})$/;
@@ -5909,26 +6334,9 @@ function truncateMessages(messages, maxChars) {
   }
   return { messages: kept, omitted: messages.length - kept.length };
 }
-function checkChannelAccess(targetChannelId, currentChannelId) {
-  const target = normalizeSlackConversationId(targetChannelId);
-  const current = normalizeSlackConversationId(currentChannelId);
-  if (!target) {
-    return { allowed: false, error: "Invalid Slack channel ID." };
-  }
-  if (target.startsWith("C")) {
-    return { allowed: true };
-  }
-  if (target === current) {
-    return { allowed: true };
-  }
-  return {
-    allowed: false,
-    error: "Cannot read private channels or DMs unless the link is from the current conversation."
-  };
-}
-function createSlackThreadReadTool(context) {
+function createSlackThreadReadTool(context, deps = {}) {
   return tool({
-    description: "Read a Slack thread from a shared Slack message archive URL or explicit channel + timestamp. Use when the user shares a Slack message link (https://*.slack.com/archives/...) and you need the referenced message and its thread context. Public channel links can be read if the bot has access; private channels and DMs are only readable when they are the current conversation.",
+    description: "Read a Slack thread from a shared Slack message archive URL or explicit channel + timestamp. Use when the user shares a Slack message link (https://*.slack.com/archives/...) and you need the referenced message and its thread context. Only the current conversation and public channels Junior has seen in this workspace are readable.",
     annotations: { readOnlyHint: true, destructiveHint: false },
     inputSchema: Type19.Object({
       url: Type19.Optional(
@@ -5988,10 +6396,15 @@ function createSlackThreadReadTool(context) {
           error: "Provide either a Slack message `url` or both `channel_id` and `ts`."
         };
       }
-      const access = checkChannelAccess(
-        channelId,
-        context.destinationChannelId
-      );
+      const access = await checkSlackChannelReadAccess({
+        currentChannelIds: [
+          context.destinationChannelId,
+          context.sourceChannelId
+        ],
+        store: deps.visibilityStore,
+        targetChannelId: channelId,
+        teamId: context.teamId
+      });
       if (!access.allowed) {
         return {
           ok: false,
@@ -10518,33 +10931,6 @@ function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor
 }
 
 // src/chat/services/reply-delivery-plan.ts
-var REACTION_ONLY_ACK_RE = /^(?::[a-z0-9_+-]+:|[\p{Extended_Pictographic}\uFE0F\u200D]+)$/u;
-var REDUNDANT_REACTION_ACK_TEXT = ["done", "got it", "ok", "okay"];
-var REACTION_INTENT_RE = /\b(react|reaction|emoji|thumbs?\s*up|acknowledge)\b/i;
-var REACTION_WITH_REPLY_INTENT_RE = /\b(confirm|explain|reply|respond|say|tell|summari[sz]e|why)\b/i;
-function normalizeReactionAckText(text) {
-  return text.trim().toLowerCase().replace(/[!.]+$/g, "");
-}
-function isRedundantReactionAckText(text) {
-  const trimmed = text.trim();
-  if (!trimmed) {
-    return false;
-  }
-  if (REACTION_ONLY_ACK_RE.test(trimmed)) {
-    return true;
-  }
-  const normalized = normalizeReactionAckText(text);
-  return REDUNDANT_REACTION_ACK_TEXT.includes(
-    normalized
-  );
-}
-function isReactionOnlyIntent(text) {
-  const normalized = text.trim();
-  if (!normalized) {
-    return false;
-  }
-  return REACTION_INTENT_RE.test(normalized) && !REACTION_WITH_REPLY_INTENT_RE.test(normalized);
-}
 function buildReplyDeliveryPlan(args) {
   const mode = args.explicitChannelPostIntent && args.channelPostPerformed ? "channel_only" : "thread";
   let attachFiles = "none";
@@ -10658,9 +11044,12 @@ function buildTurnResult(input) {
   const toolResults = newMessages.filter(isToolResultMessage);
   const assistantMessages = newMessages.filter(isAssistantMessage);
   const terminalAssistantMessages = getTerminalAssistantMessages(newMessages);
-  const primaryText = stripThinkingXmlBlocks(
+  const rawPrimaryText = stripThinkingXmlBlocks(
     terminalAssistantMessages.map((message) => extractAssistantText(message)).join("\n\n")
   ).trim();
+  const exactNoReplyMarker = isNoReplyMarker(rawPrimaryText);
+  const mixedNoReplyMarker = !exactNoReplyMarker && containsNoReplyMarker(rawPrimaryText);
+  const primaryText = exactNoReplyMarker ? "" : mixedNoReplyMarker ? stripNoReplyMarker(rawPrimaryText) : rawPrimaryText;
   const toolErrorCount = toolResults.filter((result) => result.isError).length;
   const explicitChannelPostIntent = isExplicitChannelPostIntent(userInput);
   const successfulToolNames = new Set(
@@ -10671,19 +11060,51 @@ function buildTurnResult(input) {
   );
   const canvasCreated = successfulToolNames.has("slackCanvasCreate");
   const reactionPerformed = successfulToolNames.has("slackMessageAddReaction");
+  const markerSideEffectSuccess = exactNoReplyMarker && toolErrorCount === 0 && (reactionPerformed || channelPostPerformed || replyFiles.length > 0);
+  const fileOnlySuccess = !rawPrimaryText && toolErrorCount === 0 && replyFiles.length > 0;
+  const sideEffectOnlySuccess = markerSideEffectSuccess || fileOnlySuccess;
   const baseDeliveryPlan = buildReplyDeliveryPlan({
-    explicitChannelPostIntent,
+    explicitChannelPostIntent: exactNoReplyMarker && explicitChannelPostIntent,
     channelPostPerformed,
     hasFiles: replyFiles.length > 0
   });
-  const sideEffectOnlySuccess = !primaryText && toolErrorCount === 0 && (reactionPerformed || channelPostPerformed || replyFiles.length > 0);
   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) {
+  if (exactNoReplyMarker) {
+    const markerCategory = reactionPerformed ? "reaction" : channelPostPerformed ? "channel_post" : replyFiles.length > 0 ? "file" : "none";
+    const markerContext = {
+      slackThreadId: correlation?.threadId,
+      slackUserId: correlation?.requesterId,
+      slackChannelId: correlation?.channelId,
+      runId: correlation?.runId,
+      assistantUserName,
+      modelId: botConfig.modelId
+    };
+    const markerAttributes = {
+      "app.ai.no_reply_marker": true,
+      "app.ai.no_reply_marker_category": markerCategory,
+      "app.ai.no_reply_marker_accepted": sideEffectOnlySuccess && !isProviderError
+    };
+    if (sideEffectOnlySuccess && !isProviderError) {
+      logInfo(
+        "ai_no_reply_marker_accepted",
+        markerContext,
+        markerAttributes,
+        "No-reply marker suppressed visible thread text"
+      );
+    } else if (!isProviderError) {
+      logWarn(
+        "ai_no_reply_marker_rejected",
+        markerContext,
+        markerAttributes,
+        "No-reply marker requires a successful visible side effect"
+      );
+    }
+  } else if (mixedNoReplyMarker) {
     logWarn(
-      "ai_model_response_empty",
+      "ai_no_reply_marker_mixed_text",
       {
         slackThreadId: correlation?.threadId,
         slackUserId: correlation?.requesterId,
@@ -10693,14 +11114,32 @@ function buildTurnResult(input) {
         modelId: botConfig.modelId
       },
       {
-        "app.ai.tool_results": toolResults.length,
-        "app.ai.tool_error_results": toolErrorCount,
-        "app.ai.generated_files": input.generatedFileCount
+        "app.ai.no_reply_marker": true,
+        "app.ai.no_reply_marker_mode": "mixed"
       },
-      "Model returned empty text response"
+      "No-reply marker appeared with visible assistant text"
     );
   }
-  const usedPrimaryText = Boolean(primaryText);
+  if (!primaryText && !sideEffectOnlySuccess && !isProviderError && !exactNoReplyMarker) {
+    logWarn(
+      "ai_model_response_empty",
+      {
+        slackThreadId: correlation?.threadId,
+        slackUserId: correlation?.requesterId,
+        slackChannelId: correlation?.channelId,
+        runId: correlation?.runId,
+        assistantUserName,
+        modelId: botConfig.modelId
+      },
+      {
+        "app.ai.tool_results": toolResults.length,
+        "app.ai.tool_error_results": toolErrorCount,
+        "app.ai.generated_files": input.generatedFileCount
+      },
+      "Model returned empty text response"
+    );
+  }
+  const usedPrimaryText = Boolean(rawPrimaryText);
   let outcome;
   if (isProviderError) {
     outcome = "provider_error";
@@ -10709,8 +11148,7 @@ function buildTurnResult(input) {
   } else {
     outcome = "execution_failure";
   }
-  const suppressReactionOnlyText = reactionPerformed && !channelPostPerformed && replyFiles.length === 0 && Boolean(primaryText) && isReactionOnlyIntent(userInput);
-  const rawResponseText = suppressReactionOnlyText ? "" : primaryText;
+  const rawResponseText = primaryText;
   const responseText = canvasCreated && isVerbosePostCanvasReply(rawResponseText) ? buildBriefPostCanvasReply(artifactStatePatch) : rawResponseText;
   const escapedOrRawPayload = Boolean(primaryText) && (isExecutionEscapeResponse(primaryText) || isRawToolPayloadResponse(primaryText));
   const resolvedText = escapedOrRawPayload ? "" : enforceAttachmentClaimTruth(responseText, replyFiles.length > 0);
@@ -10860,513 +11298,133 @@ function buildClassifierPrompt(args) {
       sections.push(
         "<thread-background>",
         contextText,
-        "</thread-background>",
-        ""
-      );
-    }
-  }
-  sections.push(renderCurrentInstruction(args.messageText.trim() || "[empty]"));
-  for (const block of args.currentTurnBlocks ?? []) {
-    const trimmed = block.trim();
-    if (!trimmed) {
-      continue;
-    }
-    sections.push("", trimmed);
-  }
-  return sections.join("\n");
-}
-async function selectTurnThinkingLevel(args) {
-  const trimmedContext = trimContextForRouter(args.conversationContext);
-  const instructionLength = args.messageText.trim().length;
-  const turnBlockCount = (args.currentTurnBlocks ?? []).filter(
-    (block) => block.trim().length > 0
-  ).length;
-  const prompt = buildClassifierPrompt({
-    conversationContext: trimmedContext,
-    currentTurnBlocks: args.currentTurnBlocks,
-    messageText: args.messageText
-  });
-  const logContext = {
-    slackThreadId: args.context?.threadId,
-    slackChannelId: args.context?.channelId,
-    slackUserId: args.context?.requesterId,
-    runId: args.context?.runId,
-    modelId: args.fastModelId
-  };
-  return withSpan(
-    "chat.route_thinking",
-    "chat.route_thinking",
-    logContext,
-    async () => {
-      setSpanAttributes({
-        "app.ai.router.prompt_char_count": prompt.length,
-        "app.ai.router.instruction_char_count": instructionLength,
-        "app.ai.router.context_char_count": trimmedContext?.originalCharCount ?? 0,
-        "app.ai.router.context_trimmed": trimmedContext?.truncated ?? false,
-        "app.ai.router.turn_block_count": turnBlockCount
-      });
-      const selection = await classifyTurn({
-        completeObject: args.completeObject,
-        fastModelId: args.fastModelId,
-        metadata: {
-          modelId: args.fastModelId,
-          threadId: args.context?.threadId ?? "",
-          channelId: args.context?.channelId ?? "",
-          requesterId: args.context?.requesterId ?? "",
-          runId: args.context?.runId ?? ""
-        },
-        prompt
-      });
-      const normalizedSelection = applyThinkingFloor(selection, {
-        minimum: trimmedContext || turnBlockCount > 0 ? "medium" : void 0
-      });
-      setSpanAttributes({
-        "app.ai.thinking_level": normalizedSelection.thinkingLevel,
-        "app.ai.thinking_level_reason": normalizedSelection.reason,
-        ...normalizedSelection.confidence !== void 0 ? {
-          "app.ai.thinking_level_confidence": normalizedSelection.confidence
-        } : {}
-      });
-      return normalizedSelection;
-    }
-  );
-}
-function applyThinkingFloor(selection, args) {
-  const minimum = args.minimum;
-  if (!minimum || selection.thinkingLevel === "none" || THINKING_LEVEL_RANK[selection.thinkingLevel] >= THINKING_LEVEL_RANK[minimum]) {
-    return selection;
-  }
-  return {
-    ...selection,
-    thinkingLevel: minimum,
-    reason: `thinking_floor:${minimum}:${selection.reason}`
-  };
-}
-async function classifyTurn(args) {
-  try {
-    const result = await args.completeObject({
-      modelId: args.fastModelId,
-      schema: turnExecutionProfileSchema,
-      maxTokens: 120,
-      metadata: args.metadata,
-      prompt: args.prompt,
-      thinkingLevel: "low",
-      system: buildClassifierSystemPrompt(),
-      temperature: 0
-    });
-    const parsed = turnExecutionProfileSchema.parse(result.object);
-    const reason = parsed.reason.trim();
-    if (parsed.confidence < CLASSIFIER_CONFIDENCE_THRESHOLD) {
-      return {
-        confidence: parsed.confidence,
-        thinkingLevel: DEFAULT_THINKING_LEVEL,
-        reason: `low_confidence_medium_default:${reason}`
-      };
-    }
-    return {
-      confidence: parsed.confidence,
-      thinkingLevel: parsed.thinking_level,
-      reason
-    };
-  } catch {
-    return {
-      thinkingLevel: DEFAULT_THINKING_LEVEL,
-      reason: "classifier_error_default"
-    };
-  }
-}
-function toAgentThinkingLevel(level) {
-  switch (level) {
-    case "none":
-      return "off";
-    case "low":
-      return "low";
-    case "medium":
-      return "medium";
-    case "high":
-      return "high";
-    case "xhigh":
-      return "xhigh";
-  }
-}
-
-// src/chat/usage.ts
-var COMPONENT_USAGE_FIELDS = [
-  "inputTokens",
-  "outputTokens",
-  "cachedInputTokens",
-  "cacheCreationTokens"
-];
-function hasAgentTurnUsage(usage) {
-  return Boolean(
-    usage && Object.values(usage).some(
-      (value) => typeof value === "number" && Number.isFinite(value)
-    )
-  );
-}
-function getFiniteCount(value) {
-  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : void 0;
-}
-function getComponentTotal(usage) {
-  let total;
-  for (const field of COMPONENT_USAGE_FIELDS) {
-    const value = getFiniteCount(usage[field]);
-    if (value === void 0) continue;
-    total = (total ?? 0) + value;
-  }
-  return total;
-}
-function addAgentTurnUsage(...usages) {
-  const components = {};
-  let componentTotal;
-  let totalOnlyTokens;
-  for (const usage of usages) {
-    if (!usage) continue;
-    const usageComponentTotal = getComponentTotal(usage);
-    if (usageComponentTotal !== void 0) {
-      componentTotal = (componentTotal ?? 0) + usageComponentTotal;
-      for (const field of COMPONENT_USAGE_FIELDS) {
-        const value = getFiniteCount(usage[field]);
-        if (value === void 0) continue;
-        components[field] = (components[field] ?? 0) + value;
-      }
-      continue;
-    }
-    const totalTokens = getFiniteCount(usage.totalTokens);
-    if (totalTokens !== void 0) {
-      totalOnlyTokens = (totalOnlyTokens ?? 0) + totalTokens;
-    }
-  }
-  if (totalOnlyTokens !== void 0) {
-    return {
-      totalTokens: totalOnlyTokens + (componentTotal ?? 0)
-    };
-  }
-  return hasAgentTurnUsage(components) ? components : void 0;
-}
-
-// src/chat/services/turn-session-record.ts
-var AGENT_CONTINUE_MAX_SLICES = 48;
-function logSessionRecordError(error, eventName, args, attributes, message) {
-  logException(
-    error,
-    eventName,
-    {
-      slackThreadId: args.logContext.threadId,
-      slackUserId: args.logContext.requesterId,
-      slackChannelId: args.logContext.channelId,
-      runId: args.logContext.runId,
-      assistantUserName: args.logContext.assistantUserName,
-      modelId: args.logContext.modelId
-    },
-    {
-      "app.ai.resume_conversation_id": args.conversationId,
-      "app.ai.resume_session_id": args.sessionId,
-      ...attributes
-    },
-    message
-  );
-}
-function addDurationMs(prior, current) {
-  const total = [prior, current].reduce((sum, value) => {
-    if (typeof value !== "number" || !Number.isFinite(value)) {
-      return sum;
-    }
-    return (sum ?? 0) + Math.max(0, Math.floor(value));
-  }, void 0);
-  return total;
-}
-function isContinuableBoundary(messages) {
-  const lastRole = getPiMessageRole(messages.at(-1));
-  return lastRole === "user" || lastRole === "toolResult";
-}
-function resumableBoundary(messages, fallbackMessages) {
-  const current = trimTrailingAssistantMessages(messages);
-  if (current.length > 0 && isContinuableBoundary(current)) {
-    return current;
-  }
-  return trimTrailingAssistantMessages(fallbackMessages ?? []);
-}
-async function loadTurnSessionRecord(ctx) {
-  const canUseTurnSession = Boolean(ctx.conversationId && ctx.sessionId);
-  const existingSessionRecord = canUseTurnSession && ctx.conversationId && ctx.sessionId ? await getAgentTurnSessionRecord(ctx.conversationId, ctx.sessionId) : void 0;
-  const hasAwaitingResumeRecord = Boolean(
-    existingSessionRecord && existingSessionRecord.state === "awaiting_resume"
-  );
-  return {
-    canUseTurnSession,
-    resumedFromSessionRecord: hasAwaitingResumeRecord,
-    currentSliceId: hasAwaitingResumeRecord ? existingSessionRecord.sliceId : 1,
-    existingSessionRecord
-  };
-}
-async function persistRunningSessionRecord(args) {
-  if (args.messages.length === 0 || !isContinuableBoundary(args.messages)) {
-    return false;
-  }
-  try {
-    const latestSessionRecord = await getAgentTurnSessionRecord(
-      args.conversationId,
-      args.sessionId
-    );
-    await upsertAgentTurnSessionRecord({
-      ...args.channelName ?? latestSessionRecord?.channelName ? { channelName: args.channelName ?? latestSessionRecord?.channelName } : {},
-      conversationId: args.conversationId,
-      cumulativeDurationMs: latestSessionRecord?.cumulativeDurationMs,
-      cumulativeUsage: latestSessionRecord?.cumulativeUsage,
-      ...args.destination ?? latestSessionRecord?.destination ? { destination: args.destination ?? latestSessionRecord?.destination } : {},
-      ...args.source ?? latestSessionRecord?.source ? { source: args.source ?? latestSessionRecord?.source } : {},
-      sessionId: args.sessionId,
-      sliceId: args.sliceId,
-      state: "running",
-      piMessages: args.messages,
-      ...args.surface ?? latestSessionRecord?.surface ? { surface: args.surface ?? latestSessionRecord?.surface } : {},
-      ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
-      ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
-      ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {},
-      ...(args.turnStartMessageIndex ?? latestSessionRecord?.turnStartMessageIndex) !== void 0 ? {
-        turnStartMessageIndex: args.turnStartMessageIndex ?? latestSessionRecord?.turnStartMessageIndex
-      } : {}
-    });
-    return true;
-  } catch (recordError) {
-    logSessionRecordError(
-      recordError,
-      "agent_turn_running_session_record_failed",
-      args,
-      {
-        "app.ai.resume_slice_id": args.sliceId
-      },
-      "Failed to persist running turn session record"
-    );
-    return false;
-  }
-}
-async function persistCompletedSessionRecord(args) {
-  try {
-    const latestSessionRecord = await getAgentTurnSessionRecord(
-      args.conversationId,
-      args.sessionId
-    );
-    await upsertAgentTurnSessionRecord({
-      ...args.channelName ?? latestSessionRecord?.channelName ? { channelName: args.channelName ?? latestSessionRecord?.channelName } : {},
-      conversationId: args.conversationId,
-      cumulativeDurationMs: addDurationMs(
-        latestSessionRecord?.cumulativeDurationMs,
-        args.currentDurationMs
-      ),
-      cumulativeUsage: addAgentTurnUsage(
-        latestSessionRecord?.cumulativeUsage,
-        args.currentUsage
-      ),
-      ...args.destination ?? latestSessionRecord?.destination ? { destination: args.destination ?? latestSessionRecord?.destination } : {},
-      ...args.source ?? latestSessionRecord?.source ? { source: args.source ?? latestSessionRecord?.source } : {},
-      sessionId: args.sessionId,
-      sliceId: args.sliceId,
-      state: "completed",
-      piMessages: args.allMessages,
-      ...args.surface ?? latestSessionRecord?.surface ? { surface: args.surface ?? latestSessionRecord?.surface } : {},
-      ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
-      ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
-      ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {},
-      ...(args.turnStartMessageIndex ?? latestSessionRecord?.turnStartMessageIndex) !== void 0 ? {
-        turnStartMessageIndex: args.turnStartMessageIndex ?? latestSessionRecord?.turnStartMessageIndex
-      } : {}
-    });
-  } catch (recordError) {
-    logSessionRecordError(
-      recordError,
-      "agent_turn_completed_session_record_failed",
-      args,
-      {
-        "app.ai.resume_slice_id": args.sliceId
-      },
-      "Failed to persist completed turn session record"
-    );
-  }
-}
-async function persistAuthPauseSessionRecord(args) {
-  const nextSliceId = args.currentSliceId + 1;
-  try {
-    const latestSessionRecord = await getAgentTurnSessionRecord(
-      args.conversationId,
-      args.sessionId
-    );
-    const piMessages = resumableBoundary(
-      args.messages,
-      latestSessionRecord?.piMessages
-    );
-    if (piMessages.length > 0 && !isContinuableBoundary(piMessages)) {
-      return void 0;
-    }
-    return await upsertAgentTurnSessionRecord({
-      ...args.channelName ?? latestSessionRecord?.channelName ? { channelName: args.channelName ?? latestSessionRecord?.channelName } : {},
-      conversationId: args.conversationId,
-      cumulativeDurationMs: addDurationMs(
-        latestSessionRecord?.cumulativeDurationMs,
-        args.currentDurationMs
-      ),
-      cumulativeUsage: addAgentTurnUsage(
-        latestSessionRecord?.cumulativeUsage,
-        args.currentUsage
-      ),
-      ...args.destination ?? latestSessionRecord?.destination ? { destination: args.destination ?? latestSessionRecord?.destination } : {},
-      ...args.source ?? latestSessionRecord?.source ? { source: args.source ?? latestSessionRecord?.source } : {},
-      sessionId: args.sessionId,
-      sliceId: nextSliceId,
-      state: "awaiting_resume",
-      piMessages,
-      ...args.surface ?? latestSessionRecord?.surface ? { surface: args.surface ?? latestSessionRecord?.surface } : {},
-      ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
-      resumeReason: "auth",
-      resumedFromSliceId: args.currentSliceId,
-      errorMessage: args.errorMessage,
-      ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
-      ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {}
-    });
-  } catch (recordError) {
-    logSessionRecordError(
-      recordError,
-      "agent_turn_auth_resume_session_record_failed",
-      args,
-      {
-        "app.ai.resume_from_slice_id": args.currentSliceId,
-        "app.ai.resume_next_slice_id": nextSliceId
-      },
-      "Failed to persist auth session record before retry"
-    );
-  }
-  return void 0;
-}
-async function persistTimeoutSessionRecord(args) {
-  const nextSliceId = args.currentSliceId + 1;
-  try {
-    const latestSessionRecord = await getAgentTurnSessionRecord(
-      args.conversationId,
-      args.sessionId
-    );
-    const piMessages = resumableBoundary(
-      args.messages,
-      latestSessionRecord?.piMessages
-    );
-    if (piMessages.length === 0 || !isContinuableBoundary(piMessages)) {
-      return void 0;
-    }
-    const cumulativeDurationMs = addDurationMs(
-      latestSessionRecord?.cumulativeDurationMs,
-      args.currentDurationMs
-    );
-    const cumulativeUsage = addAgentTurnUsage(
-      latestSessionRecord?.cumulativeUsage,
-      args.currentUsage
-    );
-    if (nextSliceId > AGENT_CONTINUE_MAX_SLICES) {
-      return await upsertAgentTurnSessionRecord({
-        ...args.channelName ?? latestSessionRecord?.channelName ? {
-          channelName: args.channelName ?? latestSessionRecord?.channelName
-        } : {},
-        conversationId: args.conversationId,
-        cumulativeDurationMs,
-        cumulativeUsage,
-        ...args.destination ?? latestSessionRecord?.destination ? {
-          destination: args.destination ?? latestSessionRecord?.destination
-        } : {},
-        ...args.source ?? latestSessionRecord?.source ? { source: args.source ?? latestSessionRecord?.source } : {},
-        sessionId: args.sessionId,
-        sliceId: args.currentSliceId,
-        state: "failed",
-        piMessages,
-        ...args.surface ?? latestSessionRecord?.surface ? { surface: args.surface ?? latestSessionRecord?.surface } : {},
-        ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
-        resumeReason: "timeout",
-        resumedFromSliceId: latestSessionRecord?.resumedFromSliceId,
-        errorMessage: `Agent continuation exceeded slice limit (${AGENT_CONTINUE_MAX_SLICES})`,
-        ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
-        ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {}
+        "</thread-background>",
+        ""
+      );
+    }
+  }
+  sections.push(renderCurrentInstruction(args.messageText.trim() || "[empty]"));
+  for (const block of args.currentTurnBlocks ?? []) {
+    const trimmed = block.trim();
+    if (!trimmed) {
+      continue;
+    }
+    sections.push("", trimmed);
+  }
+  return sections.join("\n");
+}
+async function selectTurnThinkingLevel(args) {
+  const trimmedContext = trimContextForRouter(args.conversationContext);
+  const instructionLength = args.messageText.trim().length;
+  const turnBlockCount = (args.currentTurnBlocks ?? []).filter(
+    (block) => block.trim().length > 0
+  ).length;
+  const prompt = buildClassifierPrompt({
+    conversationContext: trimmedContext,
+    currentTurnBlocks: args.currentTurnBlocks,
+    messageText: args.messageText
+  });
+  const logContext = {
+    slackThreadId: args.context?.threadId,
+    slackChannelId: args.context?.channelId,
+    slackUserId: args.context?.requesterId,
+    runId: args.context?.runId,
+    modelId: args.fastModelId
+  };
+  return withSpan(
+    "chat.route_thinking",
+    "chat.route_thinking",
+    logContext,
+    async () => {
+      setSpanAttributes({
+        "app.ai.router.prompt_char_count": prompt.length,
+        "app.ai.router.instruction_char_count": instructionLength,
+        "app.ai.router.context_char_count": trimmedContext?.originalCharCount ?? 0,
+        "app.ai.router.context_trimmed": trimmedContext?.truncated ?? false,
+        "app.ai.router.turn_block_count": turnBlockCount
+      });
+      const selection = await classifyTurn({
+        completeObject: args.completeObject,
+        fastModelId: args.fastModelId,
+        metadata: {
+          modelId: args.fastModelId,
+          threadId: args.context?.threadId ?? "",
+          channelId: args.context?.channelId ?? "",
+          requesterId: args.context?.requesterId ?? "",
+          runId: args.context?.runId ?? ""
+        },
+        prompt
+      });
+      const normalizedSelection = applyThinkingFloor(selection, {
+        minimum: trimmedContext || turnBlockCount > 0 ? "medium" : void 0
+      });
+      setSpanAttributes({
+        "app.ai.thinking_level": normalizedSelection.thinkingLevel,
+        "app.ai.thinking_level_reason": normalizedSelection.reason,
+        ...normalizedSelection.confidence !== void 0 ? {
+          "app.ai.thinking_level_confidence": normalizedSelection.confidence
+        } : {}
       });
+      return normalizedSelection;
     }
-    return await upsertAgentTurnSessionRecord({
-      ...args.channelName ?? latestSessionRecord?.channelName ? { channelName: args.channelName ?? latestSessionRecord?.channelName } : {},
-      conversationId: args.conversationId,
-      cumulativeDurationMs,
-      cumulativeUsage,
-      ...args.destination ?? latestSessionRecord?.destination ? { destination: args.destination ?? latestSessionRecord?.destination } : {},
-      ...args.source ?? latestSessionRecord?.source ? { source: args.source ?? latestSessionRecord?.source } : {},
-      sessionId: args.sessionId,
-      sliceId: nextSliceId,
-      state: "awaiting_resume",
-      piMessages,
-      ...args.surface ?? latestSessionRecord?.surface ? { surface: args.surface ?? latestSessionRecord?.surface } : {},
-      ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
-      resumeReason: "timeout",
-      resumedFromSliceId: args.currentSliceId,
-      errorMessage: args.errorMessage,
-      ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
-      ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {}
-    });
-  } catch (recordError) {
-    logSessionRecordError(
-      recordError,
-      "agent_continue_session_record_failed",
-      args,
-      {
-        "app.ai.resume_from_slice_id": args.currentSliceId,
-        "app.ai.resume_next_slice_id": nextSliceId
-      },
-      "Failed to persist session record before scheduling agent continuation"
-    );
-    return void 0;
+  );
+}
+function applyThinkingFloor(selection, args) {
+  const minimum = args.minimum;
+  if (!minimum || selection.thinkingLevel === "none" || THINKING_LEVEL_RANK[selection.thinkingLevel] >= THINKING_LEVEL_RANK[minimum]) {
+    return selection;
   }
+  return {
+    ...selection,
+    thinkingLevel: minimum,
+    reason: `thinking_floor:${minimum}:${selection.reason}`
+  };
 }
-async function persistYieldSessionRecord(args) {
+async function classifyTurn(args) {
   try {
-    const latestSessionRecord = await getAgentTurnSessionRecord(
-      args.conversationId,
-      args.sessionId
-    );
-    const piMessages = resumableBoundary(
-      args.messages,
-      latestSessionRecord?.piMessages
-    );
-    if (piMessages.length === 0 || !isContinuableBoundary(piMessages)) {
-      return void 0;
-    }
-    return await upsertAgentTurnSessionRecord({
-      ...args.channelName ?? latestSessionRecord?.channelName ? { channelName: args.channelName ?? latestSessionRecord?.channelName } : {},
-      conversationId: args.conversationId,
-      cumulativeDurationMs: addDurationMs(
-        latestSessionRecord?.cumulativeDurationMs,
-        args.currentDurationMs
-      ),
-      cumulativeUsage: addAgentTurnUsage(
-        latestSessionRecord?.cumulativeUsage,
-        args.currentUsage
-      ),
-      ...args.destination ?? latestSessionRecord?.destination ? { destination: args.destination ?? latestSessionRecord?.destination } : {},
-      ...args.source ?? latestSessionRecord?.source ? { source: args.source ?? latestSessionRecord?.source } : {},
-      sessionId: args.sessionId,
-      sliceId: args.currentSliceId,
-      state: "awaiting_resume",
-      piMessages,
-      ...args.surface ?? latestSessionRecord?.surface ? { surface: args.surface ?? latestSessionRecord?.surface } : {},
-      ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
-      resumeReason: "yield",
-      resumedFromSliceId: latestSessionRecord?.resumedFromSliceId,
-      errorMessage: args.errorMessage,
-      ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
-      ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {}
+    const result = await args.completeObject({
+      modelId: args.fastModelId,
+      schema: turnExecutionProfileSchema,
+      maxTokens: 120,
+      metadata: args.metadata,
+      prompt: args.prompt,
+      thinkingLevel: "low",
+      system: buildClassifierSystemPrompt(),
+      temperature: 0
     });
-  } catch (recordError) {
-    logSessionRecordError(
-      recordError,
-      "agent_turn_yield_session_record_failed",
-      args,
-      {
-        "app.ai.resume_slice_id": args.currentSliceId
-      },
-      "Failed to persist cooperative yield session record"
-    );
-    return void 0;
+    const parsed = turnExecutionProfileSchema.parse(result.object);
+    const reason = parsed.reason.trim();
+    if (parsed.confidence < CLASSIFIER_CONFIDENCE_THRESHOLD) {
+      return {
+        confidence: parsed.confidence,
+        thinkingLevel: DEFAULT_THINKING_LEVEL,
+        reason: `low_confidence_medium_default:${reason}`
+      };
+    }
+    return {
+      confidence: parsed.confidence,
+      thinkingLevel: parsed.thinking_level,
+      reason
+    };
+  } catch {
+    return {
+      thinkingLevel: DEFAULT_THINKING_LEVEL,
+      reason: "classifier_error_default"
+    };
+  }
+}
+function toAgentThinkingLevel(level) {
+  switch (level) {
+    case "none":
+      return "off";
+    case "low":
+      return "low";
+    case "medium":
+      return "medium";
+    case "high":
+      return "high";
+    case "xhigh":
+      return "xhigh";
   }
 }
 
@@ -13051,7 +13109,10 @@ function legacyTextPartMatchesCurrentText(storedText, currentText) {
 async function generateAssistantReply(messageText2, context) {
   const conversationPrivacy = resolveConversationPrivacy({
     channelId: context.correlation?.channelId,
-    conversationId: context.correlation?.conversationId ?? context.correlation?.threadId ?? context.correlation?.runId
+    conversationId: context.correlation?.conversationId ?? context.correlation?.threadId ?? context.correlation?.runId,
+    // Source-confirmed visibility from the live event's channel_type; without
+    // it the turn fails closed to private telemetry capture.
+    visibility: context.slackConversation?.visibility
   });
   return runWithConversationPrivacy(
     conversationPrivacy ?? "private",
@@ -13214,14 +13275,26 @@ async function generateAssistantReplyInPrivacyContext(messageText2, context, con
       if (!turnSessionState.canUseTurnSession || !sessionConversationId || !sessionId) {
         return;
       }
-      await recordToolExecutionStarted({
-        conversationId: sessionConversationId,
-        sessionId,
-        toolCallId: event.toolCallId,
-        toolName: event.toolName,
-        args: event.args,
-        ttlMs: THREAD_STATE_TTL_MS4
-      });
+      try {
+        await recordToolExecutionStarted({
+          conversationId: sessionConversationId,
+          sessionId,
+          toolCallId: event.toolCallId,
+          toolName: event.toolName,
+          args: event.args,
+          ttlMs: THREAD_STATE_TTL_MS4
+        });
+      } catch (error) {
+        logException(
+          error,
+          "agent_turn_session_log_append_failed",
+          spanContext,
+          {
+            "gen_ai.tool.name": event.toolName
+          },
+          "Failed to record host-only tool execution start"
+        );
+      }
     };
     const persistedConfigurationValues = context.channelConfiguration ? await context.channelConfiguration.resolveValues() : {};
     configurationValues = {
@@ -13581,10 +13654,10 @@ async function generateAssistantReplyInPrivacyContext(messageText2, context, con
     );
     const hasPromptCheckpoint = resumedFromSessionRecord && existingSessionRecord?.turnStartMessageIndex !== void 0;
     const shouldPromptAgent = !resumedFromSessionRecord || !hasPromptCheckpoint;
-    const promptHistoryMessages = shouldPromptAgent && resumedFromSessionRecord ? withoutTrailingUncheckpointedUserPrompt(
+    const promptHistoryMessages = shouldPromptAgent ? withoutTrailingUncheckpointedUserPrompt(
       priorPiMessages,
       userContentParts
-    ) : shouldPromptAgent ? priorPiMessages ?? [] : existingSessionRecord.piMessages;
+    ) : existingSessionRecord.piMessages;
     const needsBootstrapContextForPrompt = shouldPromptAgent && !hasRuntimeTurnContext(promptHistoryMessages);
     const systemPromptContributions = await getPluginSystemPromptContributions(toolSource);
     const pluginSystemPrompt = buildPluginSystemPromptContributions(
@@ -13739,12 +13812,12 @@ async function generateAssistantReplyInPrivacyContext(messageText2, context, con
         });
         if (steeredMessageCount > 0) {
           logInfo(
-            "agent_turn_steering_messages_injected",
+            "agent_turn_steering_messages_accepted",
             spanContext,
             {
               "app.ai.steering_message_count": steeredMessageCount
             },
-            "Agent turn steering messages injected"
+            "Agent turn steering messages accepted"
           );
         }
       } catch (error) {
@@ -13835,10 +13908,10 @@ async function generateAssistantReplyInPrivacyContext(messageText2, context, con
     beforeMessageCount = agent.state.messages.length;
     try {
       if (resumedFromSessionRecord) {
-        agent.state.messages = shouldPromptAgent ? promptHistoryMessages ?? [] : existingSessionRecord.piMessages;
+        agent.state.messages = shouldPromptAgent ? promptHistoryMessages : existingSessionRecord.piMessages;
         turnStartMessageIndex = existingSessionRecord.turnStartMessageIndex;
-      } else if (context.piMessages && context.piMessages.length > 0) {
-        agent.state.messages = [...context.piMessages];
+      } else if (promptHistoryMessages.length > 0) {
+        agent.state.messages = [...promptHistoryMessages];
       }
       beforeMessageCount = agent.state.messages.length;
       if (shouldPromptAgent) {
@@ -14006,22 +14079,6 @@ async function generateAssistantReplyInPrivacyContext(messageText2, context, con
     }
     if (turnSessionState.canUseTurnSession && sessionConversationId && sessionId) {
       await recordActiveMcpProviders();
-      await persistCompletedSessionRecord({
-        channelName: context.correlation?.channelName,
-        conversationId: sessionConversationId,
-        currentDurationMs: Date.now() - replyStartedAtMs,
-        currentUsage: turnUsage,
-        destination: context.destination,
-        source: runSource,
-        sessionId,
-        sliceId: currentSliceId,
-        allMessages: agent.state.messages,
-        loadedSkillNames: loadedSkillNamesForResume,
-        logContext: sessionRecordLogContext,
-        requester,
-        ...surface ? { surface } : {},
-        ...turnStartMessageIndex !== void 0 ? { turnStartMessageIndex } : {}
-      });
     }
     return buildTurnResult({
       newMessages,
@@ -14183,7 +14240,7 @@ async function generateAssistantReplyInPrivacyContext(messageText2, context, con
     );
     const message = error instanceof Error ? error.message : String(error);
     return {
-      text: `Error: ${message}`,
+      text: "",
       ...getSandboxMetadata(),
       diagnostics: {
         outcome: "provider_error",
@@ -14574,6 +14631,98 @@ function getConversationMessageSlackTs(message) {
   return message.meta?.slackTs ?? toOptionalString(message.id);
 }
 
+// src/chat/services/turn-failure-response.ts
+function requireTurnFailureEventId(eventId, eventName) {
+  if (!eventId) {
+    throw new Error(`Sentry did not return an event ID for ${eventName}`);
+  }
+  return eventId;
+}
+function getExecutionFailureReason(reply) {
+  const errorMessage = reply.diagnostics.errorMessage?.trim();
+  if (errorMessage) {
+    return errorMessage;
+  }
+  if (reply.diagnostics.toolErrorCount > 0) {
+    return `${reply.diagnostics.toolErrorCount} tool result error(s)`;
+  }
+  if (reply.diagnostics.assistantMessageCount > 0) {
+    return "assistant returned no text";
+  }
+  return "empty assistant turn";
+}
+function getFailureCapture(reply) {
+  if (reply.diagnostics.outcome === "provider_error") {
+    return {
+      eventName: "agent_turn_provider_error",
+      error: reply.diagnostics.providerError ?? new Error(
+        reply.diagnostics.errorMessage ?? "Provider error without explicit message"
+      ),
+      attributes: {},
+      body: "Agent turn failed with provider error"
+    };
+  }
+  const failureReason = getExecutionFailureReason(reply);
+  return {
+    eventName: "agent_turn_execution_failure",
+    error: new Error(`Agent turn execution failure: ${failureReason}`),
+    attributes: {
+      "app.ai.execution_failure_reason": failureReason
+    },
+    body: "Agent turn completed with execution failure"
+  };
+}
+function getAgentTurnDiagnosticsAttributes(reply) {
+  return {
+    "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
+    "gen_ai.operation.name": "invoke_agent",
+    "app.ai.outcome": reply.diagnostics.outcome,
+    "app.ai.assistant_messages": reply.diagnostics.assistantMessageCount,
+    "app.ai.tool_results": reply.diagnostics.toolResultCount,
+    "app.ai.tool_error_results": reply.diagnostics.toolErrorCount,
+    "app.ai.tool_call_count": reply.diagnostics.toolCalls.length,
+    "app.ai.used_primary_text": reply.diagnostics.usedPrimaryText,
+    ...reply.diagnostics.thinkingLevel ? {
+      "app.ai.reasoning_effort": reply.diagnostics.thinkingLevel
+    } : {},
+    ...reply.diagnostics.stopReason ? {
+      "gen_ai.response.finish_reasons": [reply.diagnostics.stopReason]
+    } : {},
+    ...reply.diagnostics.errorMessage ? { "exception.message": reply.diagnostics.errorMessage } : {}
+  };
+}
+function finalizeFailedTurnReply(args) {
+  if (args.reply.diagnostics.outcome === "success") {
+    return args.reply;
+  }
+  const capture = getFailureCapture(args.reply);
+  const eventId = requireTurnFailureEventId(
+    args.logException(
+      capture.error,
+      capture.eventName,
+      args.context,
+      {
+        ...getAgentTurnDiagnosticsAttributes(args.reply),
+        ...args.attributes,
+        ...capture.attributes
+      },
+      capture.body
+    ),
+    capture.eventName
+  );
+  const providerPartialText = args.reply.diagnostics.outcome === "provider_error" && args.reply.diagnostics.assistantMessageCount > 0 ? args.reply.text.trim() : "";
+  return {
+    ...args.reply,
+    text: providerPartialText ? `${providerPartialText}${getInterruptionMarker()}` : buildTurnFailureResponse(eventId),
+    deliveryMode: "thread",
+    deliveryPlan: {
+      mode: "thread",
+      postThreadText: true,
+      attachFiles: args.reply.files && args.reply.files.length > 0 ? "inline" : "none"
+    }
+  };
+}
+
 // src/chat/plugins/task-runner.ts
 import { pluginRunContextSchema } from "@sentry/junior-plugin-api";
 var PLUGIN_TASK_LOCK_TTL_MS = 5 * 60 * 1e3;
@@ -14763,6 +14912,7 @@ async function processPluginTask(message, options = {}) {
 }
 
 // src/chat/runtime/delivered-turn-state.ts
+var NO_VISIBLE_REPLY_CONVERSATION_TEXT = "[no visible reply]";
 function buildDeliveredTurnStatePatch(args) {
   const conversation = structuredClone(args.conversation);
   const artifactStatePatch = {
@@ -14771,6 +14921,7 @@ function buildDeliveredTurnStatePatch(args) {
   };
   const artifacts = Object.keys(artifactStatePatch).length > 0 ? mergeArtifactsState(args.artifacts, artifactStatePatch) : void 0;
   clearPendingAuth(conversation, args.sessionId);
+  const assistantText = normalizeConversationText(args.reply.text) || (args.reply.deliveryPlan?.postThreadText === false ? NO_VISIBLE_REPLY_CONVERSATION_TEXT : "[empty response]");
   markConversationMessage(conversation, args.userMessageId, {
     replied: true,
     skippedReason: void 0
@@ -14778,7 +14929,7 @@ function buildDeliveredTurnStatePatch(args) {
   upsertConversationMessage(conversation, {
     id: generateConversationId("assistant"),
     role: "assistant",
-    text: normalizeConversationText(args.reply.text) || "[empty response]",
+    text: assistantText,
     createdAtMs: Date.now(),
     author: {
       userName: botConfig.userName,
@@ -14810,7 +14961,6 @@ export {
   deliverResourceEventSubscription,
   listThreadReplies,
   postSlackMessage,
-  deleteSlackMessage,
   uploadFilesToThread,
   addReactionToMessage,
   removeReactionFromMessage,
@@ -14849,13 +14999,18 @@ export {
   isCooperativeTurnYieldError,
   TurnInputCommitLostError,
   isTurnInputCommitLostError,
+  TurnInputDeferredError,
+  isTurnInputDeferredError,
   startActiveTurn,
   markTurnClosed,
   markTurnFailed,
-  isRedundantReactionAckText,
+  persistCompletedSessionRecord,
+  completeDeliveredTurn,
+  persistYieldSessionRecord,
   finalizeMcpAuthorization,
   resolvePluginOAuthAccount,
   executeCredentialedEgressRequest,
+  buildSteeringPiMessage,
   generateAssistantReply,
   estimateTextTokens,
   getAgentContextCompactionTriggerTokens,
@@ -14869,6 +15024,9 @@ export {
   createConversationMemoryService,
   isHumanConversationMessage,
   getConversationMessageSlackTs,
+  requireTurnFailureEventId,
+  getAgentTurnDiagnosticsAttributes,
+  finalizeFailedTurnReply,
   scheduleSessionCompletedPluginTasks,
   processPluginTask,
   buildDeliveredTurnStatePatch