@sentry/junior 0.75.0 → 0.76.1

package/dist/app.js

@@ -53,10 +53,12 @@ import {
   persistThreadState,
   persistThreadStateById,
   postSlackMessage,
+  processPluginTask,
   removeReactionFromMessage,
   renderSlackLegacyAttachmentText,
   resolveBaseUrl,
   resolveSandboxEgressProviderForHost,
+  scheduleSessionCompletedPluginTasks,
   setConfigDefaults,
   setSandboxEgressAuthRequiredSignal,
   setSandboxEgressCredentialLease,
@@ -69,12 +71,41 @@ import {
   updateConversationStats,
   uploadFilesToThread,
   upsertConversationMessage
-} from "./chunk-TQ74BATR.js";
+} from "./chunk-FFGXUXMD.js";
+import {
+  CONVERSATION_WORK_CHECK_IN_INTERVAL_MS,
+  CONVERSATION_WORK_STALE_ENQUEUE_MS,
+  appendInboundMessage,
+  checkInConversationWork,
+  clearExpiredConversationLease,
+  completeConversationWork,
+  drainConversationMailbox,
+  getConversation,
+  getConversationWorkState,
+  listActiveConversationIds,
+  markConversationMessagesInjected,
+  markConversationWorkEnqueued,
+  releaseConversationWork,
+  removeActiveConversation,
+  requestConversationContinuation,
+  requestConversationWork,
+  startConversationWork
+} from "./chunk-R6Z5XWY3.js";
+import {
+  JUNIOR_THREAD_STATE_TTL_MS,
+  coerceThreadConversationState
+} from "./chunk-Z4CIQ3EB.js";
+import "./chunk-JBASI5VV.js";
 import {
   getVercelConversationWorkQueue,
   resolveConversationWorkQueueTopic,
   verifyConversationQueueMessage
-} from "./chunk-C3AM4Z4J.js";
+} from "./chunk-2ECJXSVQ.js";
+import {
+  PLUGIN_TASK_QUEUE_TOPIC,
+  createVercelQueueClient,
+  verifyPluginTaskQueueMessage
+} from "./chunk-KNFROR7R.js";
 import {
   GET,
   buildSentryConversationUrl,
@@ -82,7 +113,7 @@ import {
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext,
   setConversationTitle
-} from "./chunk-JEELK46E.js";
+} from "./chunk-ZQB37HUX.js";
 import {
   abandonAgentTurnSessionRecord,
   buildSlackOutputMessage,
@@ -90,7 +121,6 @@ import {
   escapeXml,
   failAgentTurnSessionRecord,
   getAgentTurnSessionRecord,
-  getConfiguredConversationStore,
   getInterruptionMarker,
   listAgentTurnSessionSummariesForConversation,
   loadProjection,
@@ -99,7 +129,17 @@ import {
   recordAuthorizationCompleted,
   splitSlackReplyText,
   truncateStatusText
-} from "./chunk-VNTLUFTY.js";
+} from "./chunk-KOIMO7S3.js";
+import {
+  validatePluginEgressCredentialHooks,
+  validatePluginRegistrations
+} from "./chunk-XBBC6W45.js";
+import {
+  defineJuniorPlugins,
+  pluginCatalogConfigFromEnv,
+  pluginCatalogConfigFromPluginSet,
+  pluginRuntimeRegistrationsFromPluginSet
+} from "./chunk-SG5WAA7H.js";
 import {
   bindSlackDirectCredentialSubject,
   getPluginRoutes,
@@ -108,71 +148,32 @@ import {
   setPlugins,
   validatePlugins,
   verifySlackDirectCredentialSubject
-} from "./chunk-NPVUAXUE.js";
-import {
-  validatePluginEgressCredentialHooks,
-  validatePluginRegistrations
-} from "./chunk-OZSPLAQ4.js";
+} from "./chunk-NFTMTIP3.js";
 import {
-  discoverSkills
-} from "./chunk-OJODNL2P.js";
-import {
-  coerceThreadConversationState
-} from "./chunk-74HO27II.js";
+  createPluginLogger,
+  createPluginState
+} from "./chunk-56TBVRJG.js";
 import {
-  defineJuniorPlugins,
-  pluginCatalogConfigFromEnv,
-  pluginCatalogConfigFromPluginSet,
-  pluginHookRegistrationsFromPluginSet
-} from "./chunk-EE6PJWY4.js";
+  getConversationStore,
+  getDb
+} from "./chunk-NYKJ3KON.js";
+import "./chunk-G3E7SCME.js";
 import {
-  CONVERSATION_WORK_CHECK_IN_INTERVAL_MS,
-  CONVERSATION_WORK_STALE_ENQUEUE_MS,
-  JUNIOR_THREAD_STATE_TTL_MS,
-  appendInboundMessage,
-  checkInConversationWork,
-  clearExpiredConversationLease,
-  completeConversationWork,
-  drainConversationMailbox,
-  getConversation,
-  getConversationWorkState,
-  listActiveConversationIds,
-  markConversationMessagesInjected,
-  markConversationWorkEnqueued,
-  releaseConversationWork,
-  removeActiveConversation,
-  requestConversationContinuation,
-  requestConversationWork,
-  startConversationWork
-} from "./chunk-UJ7OTHPO.js";
+  ACTIVE_LOCK_TTL_MS,
+  getStateAdapter
+} from "./chunk-Y5OFBCBZ.js";
 import {
   createSlackDestination,
   destinationKey,
-  parseDestination,
-  requireSlackDestination,
-  sameDestination
-} from "./chunk-WBZ4M5N5.js";
-import {
-  createPluginLogger,
-  createPluginState
-} from "./chunk-BNJIEFQC.js";
-import {
   downloadPrivateSlackFile,
   getHeaderString,
   getSlackClient,
   isDmChannel,
-  normalizeSlackConversationId
-} from "./chunk-62FUNJYS.js";
-import {
-  getPluginDbForRegistration,
-  validatePluginDatabaseRequirements
-} from "./chunk-D7NFH5GD.js";
-import "./chunk-XJHDZUGD.js";
-import "./chunk-G3E7SCME.js";
-import {
-  ACTIVE_LOCK_TTL_MS,
-  getStateAdapter
-} from "./chunk-ZNNTSPNF.js";
+  normalizeSlackConversationId,
+  parseDestination,
+  requireSlackDestination,
+  sameDestination
+} from "./chunk-Q6XFTRV5.js";
 import {
   FUNCTION_TIMEOUT_BUFFER_SECONDS,
   GEN_AI_PROVIDER_NAME,
@@ -194,7 +195,10 @@ import {
   setSlackReactionConfig,
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages
-} from "./chunk-FCZO7LAR.js";
+} from "./chunk-T77LUIX3.js";
+import {
+  discoverSkills
+} from "./chunk-4SCWV7TJ.js";
 import {
   CredentialUnavailableError,
   buildOAuthTokenRequest,
@@ -205,19 +209,18 @@ import {
   isPluginProvider,
   parseOAuthTokenResponse,
   setPluginCatalogConfig
-} from "./chunk-2RWFUS5F.js";
-import {
-  homeDir
-} from "./chunk-Q3XNY442.js";
+} from "./chunk-ZLMBNBUG.js";
 import {
   createRequester,
-  createRequesterFromStoredSlackRequester,
   createSlackRequester,
+  createSlackResumeRequester,
   isActorUserId,
   parseActorUserId,
   toStoredSlackRequester
-} from "./chunk-EIYL7I4S.js";
-import "./chunk-MCMROINU.js";
+} from "./chunk-VALUBQ7R.js";
+import {
+  homeDir
+} from "./chunk-Q3XNY442.js";
 import {
   buildTurnFailureResponse,
   createChatSdkLogger,
@@ -234,11 +237,14 @@ import {
   toOptionalString,
   withContext,
   withSpan
-} from "./chunk-OK4KKR7B.js";
+} from "./chunk-EJN6G5A2.js";
 import {
-  sentry_exports
-} from "./chunk-SJHUF3DP.js";
-import "./chunk-2KG3PWR4.js";
+  JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE
+} from "./chunk-OJ53FYVG.js";
+import {
+  continueTrace
+} from "./chunk-ST6YNAXG.js";
+import "./chunk-MLKGABMK.js";
 
 // src/app.ts
 import { Hono } from "hono";
@@ -738,11 +744,7 @@ function buildDispatchId(plugin, idempotencyKey) {
   return `dispatch_${digest}`;
 }
 function parseDispatchRecord(value) {
-  const candidate = value && typeof value === "object" && !Array.isArray(value) && !("source" in value) && "destination" in value ? {
-    ...value,
-    source: value.destination
-  } : value;
-  const parsed = dispatchRecordSchema.safeParse(candidate);
+  const parsed = dispatchRecordSchema.safeParse(value);
   return parsed.success ? parsed.data : void 0;
 }
 function getDispatchDestinationLockId(destination) {
@@ -962,6 +964,7 @@ function canClaimDispatch(record, nowMs) {
 async function runAgentDispatchSlice(callback, deps = {}) {
   const generateAssistantReply2 = deps.generateAssistantReply ?? generateAssistantReply;
   const scheduleCallback = deps.scheduleCallback ?? scheduleDispatchCallback;
+  const scheduleCompletedTasks = deps.scheduleSessionCompletedPluginTasks ?? scheduleSessionCompletedPluginTasks;
   const nowMs = Date.now();
   const claimedDispatch = await withDispatchLock(callback.id, async (state) => {
     const current = parseDispatchRecord(
@@ -1159,6 +1162,30 @@ async function runAgentDispatchSlice(callback, deps = {}) {
       ...failure ? { errorMessage: failure } : {},
       resultMessageTs
     });
+    if (!failure) {
+      try {
+        await scheduleCompletedTasks({
+          conversationId,
+          sessionId: getDispatchTurnId(dispatch.id)
+        });
+      } catch (error) {
+        logException(
+          error,
+          "plugin_session_completed_task_schedule_failed",
+          {
+            conversationId,
+            slackThreadId: conversationId,
+            slackChannelId: dispatch.destination.channelId,
+            runId: dispatch.id,
+            actorType: dispatch.actor.type,
+            actorId: dispatch.actor.id,
+            assistantUserName: botConfig.userName
+          },
+          {},
+          "Plugin session.completed task scheduling failed"
+        );
+      }
+    }
   } catch (error) {
     if (error instanceof AuthorizationFlowDisabledError) {
       await markDispatch({
@@ -1251,7 +1278,7 @@ import { timingSafeEqual as timingSafeEqual2 } from "crypto";
 
 // src/chat/task-execution/store.ts
 function metadataStore(options) {
-  return options.conversationStore ?? getConfiguredConversationStore();
+  return options.conversationStore ?? getConversationStore();
 }
 function duplicateInboundNudgeIdempotencyKey(message, nowMs) {
   return `duplicate:${message.conversationId}:${message.inboundMessageId}:${nowMs}`;
@@ -1695,12 +1722,11 @@ function bindDispatchCredentialSubject(options) {
 }
 function createHeartbeatContext(args) {
   const pluginName = typeof args.plugin === "string" ? args.plugin : args.plugin.manifest.name;
-  const db = typeof args.plugin === "string" ? void 0 : getPluginDbForRegistration(args.plugin);
   let dispatchCount = 0;
   return {
     plugin: { name: pluginName },
     nowMs: args.nowMs,
-    ...db ? { db } : {},
+    db: getDb(),
     state: createPluginState(pluginName),
     log: createPluginLogger(pluginName),
     agent: {
@@ -2608,13 +2634,23 @@ function resolveReplyTimeoutMs(explicitTimeoutMs) {
   const parsed = Number.parseInt(raw, 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
 }
-async function postSlackMessageBestEffort(channelId, threadTs, text) {
+async function postSlackMessageBestEffort(channelId, threadTs, text, footer) {
   try {
-    await postSlackMessage({
-      channelId,
-      threadTs,
-      text
-    });
+    if (footer) {
+      await postSlackApiReplyPosts({
+        channelId,
+        threadTs,
+        posts: [
+          {
+            text,
+            stage: "thread_reply"
+          }
+        ],
+        footer
+      });
+      return;
+    }
+    await postSlackMessage({ channelId, threadTs, text });
   } catch {
   }
 }
@@ -2665,6 +2701,9 @@ function getResumeLogContext(args, lockKey) {
     modelId: botConfig.modelId
   };
 }
+function getResumeConversationId(args, lockKey) {
+  return args.replyContext?.correlation?.conversationId ?? lockKey;
+}
 async function postResumeFailureReply(args) {
   try {
     await postSlackMessage({
@@ -2708,6 +2747,10 @@ function createResumeReplyContext(args, statusSession) {
   if (!replyContext) {
     throw new TypeError("Slack resume requires a reply context");
   }
+  if (!replyContext.source) {
+    throw new TypeError("Slack resume requires a reply context source");
+  }
+  const source = replyContext.source;
   if (replyContext.destination.platform !== "slack") {
     throw new TypeError("Slack resume requires a Slack destination");
   }
@@ -2716,6 +2759,7 @@ function createResumeReplyContext(args, statusSession) {
   const persistedChannelConfiguration = replyContext.channelConfiguration ?? (replyContext.configuration ? createReadOnlyConfigService(replyContext.configuration) : void 0);
   return {
     ...replyContext,
+    source,
     turnDeadlineAtMs: replyContext.turnDeadlineAtMs ?? requestDeadline?.deadlineAtMs,
     correlation: {
       ...replyContext.correlation,
@@ -2822,7 +2866,7 @@ async function resumeSlackTurn(args) {
     });
     await status.stop();
     const footer = buildSlackReplyFooter({
-      conversationId: runArgs.replyContext?.correlation?.conversationId ?? lockKey
+      conversationId: getResumeConversationId(runArgs, lockKey)
     });
     await postSlackApiReplyPosts({
       channelId: runArgs.channelId,
@@ -2833,6 +2877,27 @@ async function resumeSlackTurn(args) {
     });
     finalReplyDelivered = true;
     await runArgs.onSuccess?.(reply);
+    if (reply.diagnostics.outcome === "success" && replyContext.correlation?.conversationId && replyContext.correlation.turnId) {
+      try {
+        const params = {
+          conversationId: replyContext.correlation.conversationId,
+          sessionId: replyContext.correlation.turnId
+        };
+        if (runArgs.scheduleSessionCompletedPluginTasks) {
+          await runArgs.scheduleSessionCompletedPluginTasks(params);
+        } else {
+          await scheduleSessionCompletedPluginTasks(params);
+        }
+      } catch (scheduleError) {
+        logException(
+          scheduleError,
+          "plugin_session_completed_task_schedule_failed",
+          getResumeLogContext(runArgs, lockKey),
+          {},
+          "Plugin session.completed task scheduling failed"
+        );
+      }
+    }
   } catch (error) {
     await status.stop();
     const onAuthPause = runArgs.onAuthPause;
@@ -2898,13 +2963,17 @@ async function resumeSlackTurn(args) {
     try {
       await deferredPauseHandler();
       if (deferredPauseKind === "auth" && deferredAuthInfo) {
+        const footer = buildSlackReplyFooter({
+          conversationId: getResumeConversationId(runArgs, lockKey)
+        });
         await postSlackMessageBestEffort(
           runArgs.channelId,
           runArgs.threadTs,
           buildAuthPauseResponse(
             deferredAuthInfo.requesterId,
             deferredAuthInfo.providerDisplayName
-          )
+          ),
+          footer
         );
       }
       return true;
@@ -3236,7 +3305,7 @@ async function resumeAuthorizedMcpTurn(args) {
       );
       let requester;
       try {
-        requester = createRequesterFromStoredSlackRequester({
+        requester = createSlackResumeRequester({
           requester: lockedSessionRecord.requester,
           teamId: destination.teamId,
           userId: authSession.userId
@@ -3250,6 +3319,15 @@ async function resumeAuthorizedMcpTurn(args) {
         });
         return false;
       }
+      if (!lockedSessionRecord.source) {
+        await failAgentTurnSessionRecord({
+          conversationId: authSession.conversationId,
+          expectedVersion: lockedSessionRecord.version,
+          sessionId: lockedSessionId,
+          errorMessage: "Stored Slack source missing for MCP OAuth resume"
+        });
+        return false;
+      }
       await recordAuthorizationCompleted({
         conversationId: authSession.conversationId,
         kind: "mcp",
@@ -3261,15 +3339,17 @@ async function resumeAuthorizedMcpTurn(args) {
         }),
         ttlMs: THREAD_STATE_TTL_MS
       });
+      const lockedMessageTs = getTurnUserSlackMessageTs(lockedUserMessage);
       return {
         messageText: lockedUserMessage.text,
-        messageTs: getTurnUserSlackMessageTs(lockedUserMessage),
+        messageTs: lockedMessageTs,
         replyContext: {
           credentialContext: {
             actor: { type: "user", userId: requester.userId }
           },
           requester,
           destination,
+          source: lockedSessionRecord.source,
           correlation: {
             conversationId: authSession.conversationId,
             turnId: lockedSessionId,
@@ -3459,11 +3539,10 @@ function pluginFor(provider) {
 }
 function basePluginContext(plugin) {
   const pluginName = plugin.manifest.name;
-  const db = getPluginDbForRegistration(plugin);
   return {
     plugin: { name: pluginName },
     log: createPluginLogger(pluginName),
-    ...db ? { db } : {}
+    db: getDb()
   };
 }
 function parseCredentialResult(value, pluginName) {
@@ -3572,7 +3651,12 @@ async function issuePluginCredential(input) {
               plugin.manifest.name,
               tokens
             );
-          }
+          },
+          withRefresh: async (callback) => await input.userTokenStore.withRefresh(
+            currentUserId,
+            plugin.manifest.name,
+            callback
+          )
         }
       } : {},
       ...credentialSubjectUserId ? {
@@ -3588,7 +3672,12 @@ async function issuePluginCredential(input) {
               plugin.manifest.name,
               tokens
             );
-          }
+          },
+          withRefresh: async (callback) => await input.userTokenStore.withRefresh(
+            credentialSubjectUserId,
+            plugin.manifest.name,
+            callback
+          )
         }
       } : {}
     }
@@ -3908,7 +3997,7 @@ async function persistFailedOAuthReplyState(args) {
   });
 }
 async function resumeOAuthSessionRecordTurn(stored, options) {
-  if (!stored.resumeConversationId || !stored.resumeSessionId || !stored.channelId || !stored.destination || !stored.threadTs) {
+  if (!stored.resumeConversationId || !stored.resumeSessionId || !stored.channelId || !stored.destination || !stored.source || !stored.threadTs) {
     return false;
   }
   const destination = requireSlackDestination(
@@ -4027,7 +4116,7 @@ async function resumeOAuthSessionRecordTurn(stored, options) {
       );
       let requester;
       try {
-        requester = createRequesterFromStoredSlackRequester({
+        requester = createSlackResumeRequester({
           requester: lockedSessionRecord.requester,
           teamId: destination.teamId,
           userId: lockedUserMessage.author.userId
@@ -4041,6 +4130,15 @@ async function resumeOAuthSessionRecordTurn(stored, options) {
         });
         return false;
       }
+      if (!lockedSessionRecord.source) {
+        await failAgentTurnSessionRecord({
+          conversationId: stored.resumeConversationId,
+          expectedVersion: lockedSessionRecord.version,
+          sessionId: lockedSessionId,
+          errorMessage: "Stored Slack source missing for OAuth resume"
+        });
+        return false;
+      }
       await recordAuthorizationCompleted({
         conversationId: stored.resumeConversationId,
         kind: "plugin",
@@ -4052,9 +4150,10 @@ async function resumeOAuthSessionRecordTurn(stored, options) {
         }),
         ttlMs: THREAD_STATE_TTL_MS2
       });
+      const lockedMessageTs = getTurnUserSlackMessageTs(lockedUserMessage);
       return {
         messageText: lockedPendingAuth ? lockedUserMessage.text : stored.pendingMessage ?? lockedUserMessage.text,
-        messageTs: getTurnUserSlackMessageTs(lockedUserMessage),
+        messageTs: lockedMessageTs,
         replyContext: {
           credentialContext: {
             actor: {
@@ -4064,6 +4163,7 @@ async function resumeOAuthSessionRecordTurn(stored, options) {
           },
           requester,
           destination,
+          source: lockedSessionRecord.source,
           correlation: {
             conversationId: stored.resumeConversationId,
             turnId: lockedSessionId,
@@ -4151,7 +4251,8 @@ async function resumeOAuthSessionRecordTurn(stored, options) {
   return true;
 }
 async function resumePendingOAuthMessage(stored, options) {
-  if (!stored.pendingMessage || !stored.channelId || !stored.destination || !stored.threadTs) {
+  const source = stored.source;
+  if (!stored.pendingMessage || !stored.channelId || !stored.destination || !source || !stored.threadTs) {
     return;
   }
   const threadId = `slack:${stored.channelId}:${stored.threadTs}`;
@@ -4170,11 +4271,12 @@ async function resumePendingOAuthMessage(stored, options) {
     destination.teamId,
     stored.userId
   );
+  const messageTs = getTurnUserSlackMessageTs(latestUserMessage);
   await resumeAuthorizedRequest({
     messageText: stored.pendingMessage,
     channelId: stored.channelId,
     threadTs: stored.threadTs,
-    messageTs: getTurnUserSlackMessageTs(latestUserMessage),
+    messageTs,
     connectedText: "",
     generateReply: options.generateReply,
     replyContext: {
@@ -4183,6 +4285,7 @@ async function resumePendingOAuthMessage(stored, options) {
       },
       requester,
       destination: stored.destination,
+      source,
       correlation: {
         conversationId: threadId,
         channelId: stored.channelId,
@@ -5005,7 +5108,7 @@ function continueSandboxEgressTrace(request, upstreamHost, tracePropagation, cal
   if (!shouldPropagateSandboxEgressTrace(upstreamHost, tracePropagation) || !sentryTrace && !baggage) {
     return run();
   }
-  return sentry_exports.continueTrace({ sentryTrace, baggage }, run);
+  return continueTrace({ sentryTrace, baggage }, run);
 }
 function isSandboxEgressForwardedRequest(request) {
   return Boolean(
@@ -6645,7 +6748,6 @@ async function POST2(request, waitUntil, services) {
 // src/chat/task-execution/vercel-callback.ts
 import {
   handleCallback,
-  QueueClient,
   registerDevConsumer
 } from "@vercel/queue";
 
@@ -7113,7 +7215,7 @@ function registerVercelConversationWorkDevConsumer(options) {
     return void 0;
   }
   return registerDevConsumer({
-    client: new QueueClient(),
+    client: createVercelQueueClient(),
     consumerGroup: CONVERSATION_WORK_DEV_CONSUMER_GROUP,
     handler: (message, metadata) => handleConversationQueueMessage(message, metadata, options),
     retry: handleConversationQueueRetry,
@@ -7122,16 +7224,79 @@ function registerVercelConversationWorkDevConsumer(options) {
   });
 }
 
+// src/chat/plugins/task-callback.ts
+import {
+  handleCallback as handleCallback2,
+  registerDevConsumer as registerDevConsumer2
+} from "@vercel/queue";
+var PLUGIN_TASK_DEV_CONSUMER_GROUP = "junior_plugin_tasks_dev";
+var PLUGIN_TASK_MAX_DELIVERIES = 5;
+function logPluginTaskQueueMessageRejected(reason, metadata) {
+  logWarn(
+    "plugin_task_queue_message_rejected",
+    {},
+    {
+      "app.queue.consumer_group": metadata.consumerGroup,
+      "app.queue.delivery_count": metadata.deliveryCount,
+      "app.queue.message_id": metadata.messageId,
+      "app.queue.reject_reason": reason,
+      "app.queue.topic_name": metadata.topicName
+    },
+    "Plugin task queue message rejected without retry"
+  );
+}
+async function handlePluginTaskQueueMessage(message, metadata) {
+  const verification = verifyPluginTaskQueueMessage(message);
+  if (verification.status === "rejected") {
+    logPluginTaskQueueMessageRejected(verification.reason, metadata);
+    return;
+  }
+  if (verification.status === "unavailable") {
+    throw new Error(
+      `Plugin task queue message verification unavailable: ${verification.reason}`
+    );
+  }
+  await runWithTurnRequestDeadline(
+    () => processPluginTask(verification.message)
+  );
+}
+function handlePluginTaskQueueRetry(_error, metadata) {
+  if (metadata.deliveryCount >= PLUGIN_TASK_MAX_DELIVERIES) {
+    return { acknowledge: true };
+  }
+  return void 0;
+}
+function createVercelPluginTaskCallback() {
+  return handleCallback2(
+    (message, metadata) => handlePluginTaskQueueMessage(message, metadata),
+    {
+      retry: handlePluginTaskQueueRetry
+    }
+  );
+}
+function registerVercelPluginTaskDevConsumer() {
+  if (process.env.NODE_ENV !== "development") {
+    return void 0;
+  }
+  return registerDevConsumer2({
+    client: createVercelQueueClient(),
+    consumerGroup: PLUGIN_TASK_DEV_CONSUMER_GROUP,
+    handler: (message, metadata) => handlePluginTaskQueueMessage(message, metadata),
+    retry: handlePluginTaskQueueRetry,
+    topic: PLUGIN_TASK_QUEUE_TOPIC
+  });
+}
+
 // src/chat/services/subscribed-decision.ts
 import { z as z2 } from "zod";
 var replyDecisionSchema = z2.object({
   should_reply: z2.boolean().describe("Whether Junior should respond to this thread message."),
-  should_unsubscribe: z2.boolean().optional().describe(
+  should_unsubscribe: z2.boolean().describe(
     "Whether Junior should unsubscribe from this thread because the user clearly asked it to stop participating."
   ),
   confidence: z2.number().min(0).max(1).describe("Classifier confidence from 0 to 1."),
   reason: z2.string().optional().describe("Short reason for the decision.")
-});
+}).strict();
 var ROUTER_CONFIDENCE_THRESHOLD = 0.8;
 var ROUTER_CLASSIFIER_MAX_TOKENS = 240;
 var LEADING_SLACK_MENTION_RE = /^\s*<@([A-Z0-9]+)(?:\|([^>]+))?>[\s,:-]*/i;
@@ -9059,6 +9224,9 @@ function createJuniorRuntimeServices(overrides = {}) {
       getAwaitingAgentContinueRequest: overrides.replyExecutor?.getAwaitingAgentContinueRequest ?? getAwaitingAgentContinueRequest,
       lookupSlackUser: overrides.replyExecutor?.lookupSlackUser ?? lookupSlackUser,
       scheduleAgentContinue: overrides.replyExecutor?.scheduleAgentContinue ?? scheduleAgentContinue,
+      scheduleSessionCompletedPluginTasks: overrides.replyExecutor?.scheduleSessionCompletedPluginTasks ?? (async (params) => {
+        await scheduleSessionCompletedPluginTasks(params);
+      }),
       generateThreadTitle: conversationMemory.generateThreadTitle
     },
     subscribedReplyPolicy: createSubscribedReplyPolicy({
@@ -9068,6 +9236,9 @@ function createJuniorRuntimeServices(overrides = {}) {
   };
 }
 
+// src/chat/runtime/reply-executor.ts
+import { createSlackSource } from "@sentry/junior-plugin-api";
+
 // src/chat/slack/message.ts
 function isSlackMessageTs(value) {
   return /^\d+(?:\.\d+)?$/.test(value.trim());
@@ -9277,10 +9448,11 @@ function createReplyToThread(deps) {
     const threadId = getThreadId(thread, message);
     const channelId = getChannelId(thread, message);
     const channelName = channelId ? await resolveChannelName(thread) : void 0;
+    const slackChannelType = resolveSlackChannelTypeFromMessage(message);
     const slackConversation = resolveSlackConversationContext({
       channelId,
       channelName,
-      channelType: resolveSlackChannelTypeFromMessage(message)
+      channelType: slackChannelType
     });
     const threadTs = getThreadTs(threadId);
     const assistantThreadContext = getAssistantThreadContext(message);
@@ -9290,6 +9462,12 @@ function createReplyToThread(deps) {
       "Slack reply execution"
     );
     const teamId = destination.teamId;
+    const source = createSlackSource({
+      channelId: channelId ?? destination.channelId,
+      messageTs,
+      teamId,
+      threadTs
+    });
     const runId = getRunId(thread, message);
     const conversationId = threadId ?? runId;
     await withSpan(
@@ -9329,12 +9507,12 @@ function createReplyToThread(deps) {
             )
           )
         );
-        const requesterIdentity = await ensureSlackMessageActorIdentity(
+        const requester = await ensureSlackMessageActorIdentity(
           message,
           teamId,
           deps.services.lookupSlackUser
         );
-        const requester = turnRequester(requesterIdentity);
+        const storedRequester = turnRequester(requester);
         const preparedState = options.preparedState ?? await deps.prepareTurnState({
           thread,
           message,
@@ -9370,16 +9548,29 @@ function createReplyToThread(deps) {
           await options.beforeFirstResponsePost?.();
         };
         const postAuthPauseNotice = async (providerDisplayName) => {
+          const text = buildAuthPauseResponse(
+            message.author.userId,
+            providerDisplayName
+          );
+          const footer = buildSlackReplyFooter({ conversationId });
           try {
-            await beforeFirstResponsePost();
-            await thread.post(
-              buildSlackOutputMessage(
-                buildAuthPauseResponse(
-                  message.author.userId,
-                  providerDisplayName
-                )
-              )
-            );
+            if (channelId && threadTs) {
+              await postSlackApiReplyPosts({
+                beforePost: beforeFirstResponsePost,
+                channelId,
+                threadTs,
+                posts: [
+                  {
+                    text,
+                    stage: "thread_reply"
+                  }
+                ],
+                footer
+              });
+            } else {
+              await beforeFirstResponsePost();
+              await thread.post(buildSlackOutputMessage(text));
+            }
           } catch (error) {
             logException(
               error,
@@ -9515,6 +9706,7 @@ function createReplyToThread(deps) {
             surface: "slack",
             requester,
             destination,
+            source,
             traceId: getActiveTraceId()
           }).catch((error) => {
             logException(
@@ -9528,7 +9720,7 @@ function createReplyToThread(deps) {
           void initConversationContext(conversationId, {
             channelName,
             originSurface: "slack",
-            originRequester: requester,
+            originRequester: storedRequester,
             startedAtMs: turnStartedAtMs
           }).catch((error) => {
             logException(
@@ -9578,12 +9770,12 @@ function createReplyToThread(deps) {
         if (message.author.userId) {
           setSentryUser({
             id: message.author.userId,
-            ...requesterIdentity.userName ? { username: requesterIdentity.userName } : {},
-            ...requesterIdentity.email ? { email: requesterIdentity.email } : {}
+            ...requester.userName ? { username: requester.userName } : {},
+            ...requester.email ? { email: requester.email } : {}
           });
         }
-        if (requesterIdentity.userName) {
-          setTags({ slackUserName: requesterIdentity.userName });
+        if (requester.userName) {
+          setTags({ slackUserName: requester.userName });
         }
         const turnAttachments = collectTurnAttachments(
           message,
@@ -9763,7 +9955,7 @@ function createReplyToThread(deps) {
               credentialContext: {
                 actor: { type: "user", userId: message.author.userId }
               },
-              requester: requesterIdentity,
+              requester,
               conversationContext: preparedState.conversationContext,
               artifactState: preparedState.artifacts,
               piMessages,
@@ -9774,6 +9966,7 @@ function createReplyToThread(deps) {
               omittedImageAttachmentCount,
               userAttachments,
               slackConversation,
+              source,
               destination,
               surface: "slack",
               turnDeadlineAtMs: getTurnRequestDeadline()?.deadlineAtMs,
@@ -9940,6 +10133,7 @@ function createReplyToThread(deps) {
               state: "completed",
               requester,
               destination,
+              source,
               traceId: getActiveTraceId()
             });
           }
@@ -9958,6 +10152,22 @@ function createReplyToThread(deps) {
             );
           }
           await options.onTurnCompleted?.();
+          if (reply.diagnostics.outcome === "success" && conversationId) {
+            try {
+              await deps.services.scheduleSessionCompletedPluginTasks({
+                conversationId,
+                sessionId: turnId
+              });
+            } catch (error) {
+              logException(
+                error,
+                "plugin_session_completed_task_schedule_failed",
+                turnTraceContext,
+                {},
+                "Plugin session.completed task scheduling failed"
+              );
+            }
+          }
         } catch (error) {
           if (isCooperativeTurnYieldError(error)) {
             shouldPersistFailureState = false;
@@ -10093,6 +10303,7 @@ function createReplyToThread(deps) {
                   state: "failed",
                   requester,
                   destination,
+                  source,
                   traceId: getActiveTraceId()
                 });
                 const sessionRecord = await getAgentTurnSessionRecord(
@@ -10642,6 +10853,7 @@ async function continueSlackAgentRun(payload, options = {}) {
     threadTs: thread.threadTs,
     lockKey: payload.conversationId,
     generateReply: options.generateReply,
+    scheduleSessionCompletedPluginTasks: options.scheduleSessionCompletedPluginTasks,
     beforeStart: async () => {
       let sessionRecord;
       try {
@@ -10678,11 +10890,20 @@ async function continueSlackAgentRun(payload, options = {}) {
           payload.destination,
           "Slack continuation"
         );
-        const requester = createRequesterFromStoredSlackRequester({
+        const requester = createSlackResumeRequester({
           requester: activeSessionRecord.requester,
           teamId: destination.teamId,
           userId: userMessage2.author.userId
         });
+        if (!activeSessionRecord.source) {
+          await failAgentTurnSessionRecord({
+            conversationId: payload.conversationId,
+            expectedVersion: activeSessionRecord.version,
+            sessionId: payload.sessionId,
+            errorMessage: "Stored Slack source missing for continuation"
+          });
+          return false;
+        }
         return {
           messageText: userMessage2.text,
           messageTs: getTurnUserSlackMessageTs(userMessage2),
@@ -10695,6 +10916,7 @@ async function continueSlackAgentRun(payload, options = {}) {
             },
             requester,
             destination: payload.destination,
+            source: activeSessionRecord.source,
             correlation: {
               conversationId: payload.conversationId,
               turnId: payload.sessionId,
@@ -10878,7 +11100,7 @@ function getProductionSlackAdapter() {
   return productionSlackAdapter;
 }
 function getProductionConversationStore() {
-  return getConfiguredConversationStore();
+  return getConversationStore();
 }
 function createProductionSlackWebhookServices(options) {
   const conversationStore = getProductionConversationStore();
@@ -10910,7 +11132,8 @@ function createProductionConversationWorkOptions(options) {
         generateReply: withSandboxTracePropagation(
           generateAssistantReply,
           options?.services?.sandbox?.tracePropagation
-        )
+        ),
+        scheduleSessionCompletedPluginTasks: options?.services?.replyExecutor?.scheduleSessionCompletedPluginTasks
       }),
       runtime
     })
@@ -10938,7 +11161,7 @@ async function resolveVirtualConfig() {
     return {
       pluginSet: mod.pluginSet,
       plugins: mod.plugins,
-      pluginHookRegistrations: mod.pluginHookRegistrations ?? []
+      pluginRuntimeRegistrations: mod.pluginRuntimeRegistrations ?? []
     };
   } catch (error) {
     if (!isMissingVirtualConfig(error)) {
@@ -10980,22 +11203,22 @@ function validateBuildIncludesPluginPackages(pluginConfig, virtualConfig) {
     `createApp() registered plugin package(s) not bundled by juniorNitro(): ${missing.join(", ")}. Point juniorNitro({ plugins: "./plugins" }) at the runtime plugin module or pass the same defineJuniorPlugins(...) set to juniorNitro({ plugins }) and createApp({ plugins }).`
   );
 }
-function validateBuildIncludesPluginHookRegistrations(hookRegistrations, virtualConfig) {
-  const bundledHookRegistrations = virtualConfig?.pluginHookRegistrations ?? [];
-  if (bundledHookRegistrations.length === 0) {
+function validateBuildIncludesPluginRuntimeRegistrations(runtimeRegistrations, virtualConfig) {
+  const bundledRuntimeRegistrations = virtualConfig?.pluginRuntimeRegistrations ?? [];
+  if (bundledRuntimeRegistrations.length === 0) {
     return;
   }
   const registered = new Set(
-    hookRegistrations.map((plugin) => plugin.manifest.name)
+    runtimeRegistrations.map((plugin) => plugin.manifest.name)
   );
-  const missing = bundledHookRegistrations.filter(
+  const missing = bundledRuntimeRegistrations.filter(
     (pluginName) => !registered.has(pluginName)
   );
   if (missing.length === 0) {
     return;
   }
   throw new Error(
-    `createApp() is missing plugin registration(s) with runtime hooks bundled by juniorNitro(): ${missing.join(", ")}. Pass a runtime-safe plugin module to juniorNitro({ plugins: "./plugins" }) or pass the same defineJuniorPlugins(...) set to createApp({ plugins }).`
+    `createApp() is missing plugin registration(s) with runtime code bundled by juniorNitro(): ${missing.join(", ")}. Pass a runtime-safe plugin module to juniorNitro({ plugins: "./plugins" }) or pass the same defineJuniorPlugins(...) set to createApp({ plugins }).`
   );
 }
 function mountPluginRoutes(app, routes) {
@@ -11015,14 +11238,14 @@ function mountPluginRoutes(app, routes) {
 async function createApp(options) {
   const virtualConfig = await resolveVirtualConfig();
   const configuredPlugins = options?.plugins ?? virtualConfig?.pluginSet;
-  const plugins = pluginHookRegistrationsFromPluginSet(configuredPlugins);
+  const plugins = pluginRuntimeRegistrationsFromPluginSet(configuredPlugins);
   const pluginConfig = configuredPlugins ? pluginCatalogConfigFromPluginSet(configuredPlugins) : virtualConfig?.plugins ?? pluginCatalogConfigFromEnv();
   if (configuredPlugins) {
     validateBuildIncludesPluginPackages(pluginConfig, virtualConfig);
   }
-  validateBuildIncludesPluginHookRegistrations(plugins, virtualConfig);
+  validateBuildIncludesPluginRuntimeRegistrations(plugins, virtualConfig);
   validatePlugins(plugins);
-  validatePluginDatabaseRequirements(plugins);
+  getDb();
   const shouldValidatePluginCatalog = hasConfiguredPluginCatalog(pluginConfig) || Boolean(configuredPlugins?.registrations.length) || Boolean(Object.keys(options?.configDefaults ?? {}).length);
   const previousPluginCatalogConfig = setPluginCatalogConfig(pluginConfig);
   const previousPlugins = setPlugins(plugins);
@@ -11097,6 +11320,7 @@ async function createApp(options) {
     });
   });
   let agentContinuePOST;
+  let pluginTaskPOST;
   let conversationWorkOptions;
   const getConversationWorkOptions = () => {
     conversationWorkOptions ??= options?.conversationWork ?? createProductionConversationWorkOptions({
@@ -11106,6 +11330,7 @@ async function createApp(options) {
   };
   if (process.env.NODE_ENV === "development") {
     registerVercelConversationWorkDevConsumer(getConversationWorkOptions());
+    registerVercelPluginTaskDevConsumer();
   }
   app.post("/api/internal/agent/continue", (c) => {
     agentContinuePOST ??= createVercelConversationWorkCallback(
@@ -11113,6 +11338,10 @@ async function createApp(options) {
     );
     return agentContinuePOST(c.req.raw);
   });
+  app.post(JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE, (c) => {
+    pluginTaskPOST ??= createVercelPluginTaskCallback();
+    return pluginTaskPOST(c.req.raw);
+  });
   app.get("/api/internal/heartbeat", (c) => {
     return GET2(c.req.raw, waitUntil);
   });