@sentry/junior 0.138.0 → 0.140.0

package/dist/app.js

@@ -1,15 +1,15 @@
 import {
   processConversationWork
-} from "./chunk-HIWJWWMT.js";
+} from "./chunk-VRDHAITB.js";
 import {
   bindSpawnAgent
-} from "./chunk-PB3CXNVL.js";
+} from "./chunk-XROWZSOY.js";
 import {
   createAgentInvocationWorker,
   enqueueAgentInvocation,
   listPendingAgentInvocationMailboxAppends,
   routeAgentInvocationWork
-} from "./chunk-ZBSMCXKV.js";
+} from "./chunk-5YAWB2AX.js";
 import {
   GET as GET2,
   GET2 as GET3,
@@ -39,7 +39,7 @@ import {
   splitSlackReplyText,
   startSlackProcessingReaction,
   stripLeadingBotMention
-} from "./chunk-E5UYAIKJ.js";
+} from "./chunk-Z2A7BDHT.js";
 import "./chunk-FA6POGLH.js";
 import {
   CONVERSATION_WORK_STALE_ENQUEUE_MS,
@@ -51,32 +51,50 @@ import {
   isInvalidConversationRecordError,
   listActiveConversationIds,
   removeActiveConversation
-} from "./chunk-5LTJ4ITU.js";
+} from "./chunk-AA2EPMUF.js";
 import {
   buildDeliveredTurnStatePatch,
+  claimDispatchMailboxAppend,
   completeAuthPauseTurn,
+  confirmDispatchMailboxAppend,
+  createOrGetDispatch,
   finalizeFailedTurnReplyWithEvent,
   getAgentTurnDiagnosticsAttributes,
+  getDispatchConversationId,
+  getDispatchInputMessageId,
+  getDispatchInputMessageIds,
+  getDispatchRecord,
+  getDispatchTurnId,
+  getPluginDispatchProjection,
   getTurnUserMessage,
   getTurnUserReplyAttachmentContext,
   getTurnUserSlackMessageTs,
+  isTerminalDispatchStatus,
+  listPendingDispatchMailboxAppends,
+  markDispatchAwaitingResume,
+  markDispatchBlocked,
+  markDispatchCompleted,
+  markDispatchFailed,
+  markDispatchRunning,
   persistAuthPauseTurnState,
   processPluginTask,
   requireTurnFailureEventId,
   resolveTurnSessionRouting,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-FEUNPTGV.js";
+} from "./chunk-A6BI25J3.js";
 import {
   ConversationTurnLifecycleService
 } from "./chunk-Q6QZTTLS.js";
 import {
   GET,
   conversationVisibilityFromSlackChannelType,
-  recordTaskExecution,
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext
-} from "./chunk-ELKW5FIB.js";
+} from "./chunk-TGIKZJ3Y.js";
 import "./chunk-4CODA7P5.js";
+import {
+  recordTaskExecution
+} from "./chunk-3B7O3GNU.js";
 import "./chunk-UTL3MHPC.js";
 import {
   getVercelConversationWorkQueue,
@@ -95,7 +113,7 @@ import {
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-YU5QUF67.js";
+} from "./chunk-TKTZ4L4Z.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
@@ -128,18 +146,18 @@ import {
   setConfigDefaults,
   shouldEmitDevAgentTrace,
   shouldPropagateSandboxEgressTrace
-} from "./chunk-RZIBSCYC.js";
+} from "./chunk-MYVCHWDG.js";
 import {
   AuthorizationFlowDisabledError,
   PluginCredentialFailureError
-} from "./chunk-LPVUNO2W.js";
+} from "./chunk-DMDOKRPC.js";
 import "./chunk-DIB4GX3G.js";
 import {
   createUserTokenStore,
   deleteMcpAuthSessionsForUserProvider,
   deleteMcpServerSessionId,
   deleteMcpStoredOAuthCredentials
-} from "./chunk-N7WARMC6.js";
+} from "./chunk-3CUBAGA3.js";
 import {
   RetryableDeliveryError
 } from "./chunk-R776HKPK.js";
@@ -147,7 +165,7 @@ import {
   formatProviderLabel,
   postSlackMessage,
   startOAuthFlow
-} from "./chunk-SD3OFRWY.js";
+} from "./chunk-5KAZMR5U.js";
 import {
   ConversationTurnBoundaryError,
   CooperativeTurnYieldError,
@@ -203,11 +221,9 @@ import {
   trimTrailingAssistantMessages,
   updateConversationStats,
   upsertConversationMessage
-} from "./chunk-TUUDXEXU.js";
-import {
-  JUNIOR_THREAD_STATE_TTL_MS
-} from "./chunk-3Y47VMHV.js";
-import "./chunk-EPBBYMNE.js";
+} from "./chunk-BMFRFSTM.js";
+import "./chunk-3Y47VMHV.js";
+import "./chunk-HUO3UTAQ.js";
 import {
   getExperimentalFeatures,
   setExperimentalFeatures
@@ -215,14 +231,16 @@ import {
 import {
   getSandboxResourceConfig,
   setSandboxResourceConfig
-} from "./chunk-A7WCHXZV.js";
+} from "./chunk-OGNL2QY7.js";
 import {
   createSchedulerSqlStore,
-  findMatchingEventTasks
-} from "./chunk-TDJCLNDH.js";
+  findMatchingEventTasks,
+  logScheduledTaskRunSkipped,
+  scheduledTaskRunAttributes
+} from "./chunk-XX2QNQN4.js";
 import {
   parseSlackThreadId
-} from "./chunk-FNLBTB4K.js";
+} from "./chunk-WTGLUX4K.js";
 import "./chunk-CDQ4YIZM.js";
 import "./chunk-PDO5BLNM.js";
 import "./chunk-UIE3R5XU.js";
@@ -242,7 +260,7 @@ import {
   verifyEventTaskCredentialSubject,
   verifyScheduledTaskCredentialSubject,
   verifySlackDirectCredentialSubject
-} from "./chunk-5MXWHTCK.js";
+} from "./chunk-4PIT6O7A.js";
 import {
   SlackActionError,
   downloadPrivateSlackFile,
@@ -252,7 +270,7 @@ import {
   normalizeSlackConversationId,
   runWithSlackInstallationToken,
   runWithWorkspaceTeamId
-} from "./chunk-TCS76X5D.js";
+} from "./chunk-HEFBGCCU.js";
 import {
   contextProvenance,
   createSlackDestination,
@@ -264,20 +282,20 @@ import {
   requireSlackDestination,
   withConversationEventLock,
   withConversationMutationLock
-} from "./chunk-SIPKWSXK.js";
+} from "./chunk-WSWM6A3R.js";
 import {
   juniorAgentBindings,
   juniorAgentInvocations,
   juniorConversationEvents,
   juniorConversations
-} from "./chunk-DCLLQGS6.js";
+} from "./chunk-557HLSNH.js";
 import {
   sleep
 } from "./chunk-EM225ITJ.js";
 import {
   acquireActiveLock,
   getStateAdapter
-} from "./chunk-BOLJOV5T.js";
+} from "./chunk-J5H65GY2.js";
 import {
   STANDARD_MODEL_PROFILE,
   botConfig,
@@ -295,19 +313,19 @@ import {
   modelIdForProfile,
   setSlackReactionConfig,
   standardModelId
-} from "./chunk-BYW4B4PR.js";
+} from "./chunk-S3FAOKQU.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
-import "./chunk-VPZFVJND.js";
-import "./chunk-ZXNTJJIE.js";
+import "./chunk-UXMRN2ZX.js";
+import "./chunk-D3X2PI3D.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-QS527AV5.js";
-import "./chunk-KFRHRSCJ.js";
+} from "./chunk-N2I7W2VS.js";
+import "./chunk-I3OZR3HG.js";
 import {
-  credentialSubjectSchema
-} from "./chunk-77VDLF3Z.js";
+  credentialContextForActor
+} from "./chunk-RUIXF3YQ.js";
 import {
   createActor,
   createSlackActor,
@@ -336,7 +354,7 @@ import {
   withContext,
   withLogContext,
   withSpan
-} from "./chunk-JNNJZURV.js";
+} from "./chunk-NPL66ZWL.js";
 import {
   continueTrace
 } from "./chunk-6GWA276C.js";
@@ -344,10 +362,10 @@ import "./chunk-OOUNJNMR.js";
 import "./chunk-H4HBKISO.js";
 import {
   JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE
-} from "./chunk-KDCHVT25.js";
+} from "./chunk-YB363QGA.js";
 import {
   JUNIOR_VERSION
-} from "./chunk-C7ZVPO4Z.js";
+} from "./chunk-CPPTBHQN.js";
 import "./chunk-MLKGABMK.js";
 
 // src/app.ts
@@ -409,400 +427,20 @@ async function verifyDispatchCallbackRequest(request) {
   }
 }
 
-// src/chat/agent-dispatch/store.ts
-import { createHash } from "crypto";
-import {
-  destinationSchema,
-  destinationVisibilitySchema,
-  isSlackDestination,
-  replyAttributionSchema,
-  sourceSchema
-} from "@sentry/junior-plugin-api";
-import { z as z2 } from "zod";
-var DISPATCH_PREFIX = "junior:agent_dispatch";
-var DISPATCH_LOCK_TTL_MS = 10 * 60 * 1e3;
-var DISPATCH_MAILBOX_APPEND_INDEX_LOCK_TTL_MS = 1e4;
-var DISPATCH_MAILBOX_APPEND_INDEX_MAX_LENGTH = 1e4;
-var nonEmptyExactStringSchema = z2.string().min(1).refine(
-  (value) => value === value.trim() && value.toLowerCase() !== "unknown"
-);
-var pendingDispatchMailboxAppendIndexSchema = z2.array(
-  nonEmptyExactStringSchema
-);
-var dispatchStatusSchema = z2.enum([
-  "pending",
-  "running",
-  "awaiting_resume",
-  "completed",
-  "failed",
-  "blocked"
-]);
-var dispatchActorSchema = z2.object({
-  platform: z2.literal("system"),
-  name: nonEmptyExactStringSchema
-}).strict();
-var dispatchRecordSchema = z2.object({
-  actor: dispatchActorSchema,
-  createdAtMs: z2.number().finite(),
-  credentialSubject: credentialSubjectSchema.optional(),
-  destination: destinationSchema,
-  destinationVisibility: destinationVisibilitySchema,
-  errorMessage: z2.string().optional(),
-  id: nonEmptyExactStringSchema,
-  idempotencyKey: z2.string().min(1),
-  input: z2.string().min(1),
-  metadata: z2.record(z2.string(), z2.string()).optional(),
-  plugin: nonEmptyExactStringSchema,
-  replyAttribution: replyAttributionSchema.optional(),
-  resultMessageTs: z2.string().optional(),
-  source: sourceSchema,
-  status: dispatchStatusSchema,
-  updatedAtMs: z2.number().finite()
-}).strict().superRefine((record, ctx) => {
-  if (!isSlackDestination(record.destination)) {
-    ctx.addIssue({
-      code: z2.ZodIssueCode.custom,
-      message: "Dispatch destination platform must be slack",
-      path: ["destination"]
-    });
-    return;
-  }
-  const subject = record.credentialSubject;
-  if (!subject) {
-    return;
-  }
-  if (subject.allowedWhen === "private-direct-conversation") {
-    if (!record.destination.channelId.startsWith("D")) {
-      ctx.addIssue({
-        code: z2.ZodIssueCode.custom,
-        message: "Dispatch credentialSubject requires a private direct Slack destination",
-        path: ["credentialSubject"]
-      });
-      return;
-    }
-    if (subject.binding.type !== "slack-direct-conversation" || subject.binding.teamId !== record.destination.teamId || subject.binding.channelId !== record.destination.channelId) {
-      ctx.addIssue({
-        code: z2.ZodIssueCode.custom,
-        message: "Dispatch credentialSubject binding must match destination",
-        path: ["credentialSubject", "binding"]
-      });
-    }
-    return;
-  }
-  if (subject.binding.type !== subject.allowedWhen || subject.binding.plugin !== record.plugin || subject.binding.taskId !== subject.taskId) {
-    ctx.addIssue({
-      code: z2.ZodIssueCode.custom,
-      message: "Dispatch credentialSubject binding must match task",
-      path: ["credentialSubject", "binding"]
-    });
-  }
-});
-var storedDispatchRecordSchema = dispatchRecordSchema.extend({
-  attempt: z2.number().int().nonnegative().optional(),
-  lastCallbackAtMs: z2.number().finite().optional(),
-  leaseExpiresAtMs: z2.number().finite().optional(),
-  maxAttempts: z2.number().int().positive().optional(),
-  version: z2.number().int().positive().optional()
-});
-function getDispatchStorageKey(id) {
-  return `${DISPATCH_PREFIX}:record:${id}`;
-}
-function dispatchLockKey(id) {
-  return `${DISPATCH_PREFIX}:lock:${id}`;
-}
-function pendingDispatchMailboxAppendIndexKey() {
-  return `${DISPATCH_PREFIX}:incomplete`;
-}
-function pendingDispatchMailboxAppendIndexLockKey() {
-  return `${DISPATCH_PREFIX}:incomplete:lock`;
-}
-function normalizeMetadata(metadata) {
-  if (!metadata) {
-    return void 0;
-  }
-  const entries = Object.entries(metadata).filter(
-    (entry) => typeof entry[0] === "string" && typeof entry[1] === "string"
-  );
-  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
-}
-function buildDispatchId(plugin, idempotencyKey) {
-  const digest = createHash("sha256").update(plugin).update("\0").update(idempotencyKey).digest("hex").slice(0, 32);
-  return `dispatch_${digest}`;
-}
-function parseDispatchRecord(value) {
-  const parsed = parseStoredDispatchRecord(value);
-  return parsed?.record;
-}
-function parseStoredDispatchRecord(value) {
-  const parsed = storedDispatchRecordSchema.safeParse(value);
-  if (!parsed.success) {
-    return void 0;
-  }
-  const {
-    attempt: _attempt,
-    lastCallbackAtMs: _lastCallbackAtMs,
-    leaseExpiresAtMs: _leaseExpiresAtMs,
-    maxAttempts: _maxAttempts,
-    version: _version,
-    ...record
-  } = parsed.data;
-  return {
-    ...typeof parsed.data.leaseExpiresAtMs === "number" ? { legacyLeaseExpiresAtMs: parsed.data.leaseExpiresAtMs } : {},
-    record
-  };
-}
-function getDispatchConversationId(dispatch2) {
-  return `agent-dispatch:${dispatch2.id}`;
-}
-function getDispatchInputMessageId(dispatchId) {
-  return `agent-dispatch:${dispatchId}`;
-}
-function getLegacyDispatchInputMessageId(dispatchId) {
-  return `dispatch:${dispatchId}:user`;
-}
-function getDispatchInputMessageIds(dispatchId) {
-  return [
-    getDispatchInputMessageId(dispatchId),
-    getLegacyDispatchInputMessageId(dispatchId)
-  ];
-}
-function getDispatchTurnId(dispatchId) {
-  return `dispatch:${dispatchId}`;
-}
-function toDispatchProjection(record) {
-  return {
-    id: record.id,
-    status: record.status,
-    ...record.resultMessageTs ? { resultMessageTs: record.resultMessageTs } : {},
-    ...record.errorMessage ? { errorMessage: record.errorMessage } : {}
-  };
-}
-function isTerminalDispatchStatus(status) {
-  return status === "completed" || status === "failed" || status === "blocked";
-}
-async function withDispatchLock(dispatchId, task) {
-  const state = getStateAdapter();
-  await state.connect();
-  const lock = await state.acquireLock(
-    dispatchLockKey(dispatchId),
-    DISPATCH_LOCK_TTL_MS
-  );
-  if (!lock) {
-    throw new Error(`Could not acquire dispatch lock for ${dispatchId}`);
-  }
-  try {
-    return await task(state);
-  } finally {
-    await state.releaseLock(lock);
-  }
-}
-async function putRecord(state, record) {
-  const parsed = dispatchRecordSchema.safeParse(record);
-  if (!parsed.success) {
-    throw new Error(
-      `Dispatch record is invalid: ${parsed.error.issues.map((issue) => `${issue.path.join(".") || "<root>"} ${issue.message}`).join("; ")}`
-    );
-  }
-  const next = parsed.data;
-  await state.set(
-    getDispatchStorageKey(next.id),
-    next,
-    JUNIOR_THREAD_STATE_TTL_MS
-  );
-}
-async function updatePendingDispatchMailboxAppendIndex(state, update) {
-  const lock = await state.acquireLock(
-    pendingDispatchMailboxAppendIndexLockKey(),
-    DISPATCH_MAILBOX_APPEND_INDEX_LOCK_TTL_MS
-  );
-  if (!lock) {
-    throw new Error("Could not acquire dispatch mailbox append index lock");
-  }
-  try {
-    const stored = await state.get(pendingDispatchMailboxAppendIndexKey());
-    const ids = stored === void 0 || stored === null ? [] : pendingDispatchMailboxAppendIndexSchema.parse(stored);
-    const next = [...new Set(update([...new Set(ids)]))].slice(
-      -DISPATCH_MAILBOX_APPEND_INDEX_MAX_LENGTH
-    );
-    if (next.length === ids.length && next.every((id, index) => id === ids[index])) {
-      return;
-    }
-    await state.set(
-      pendingDispatchMailboxAppendIndexKey(),
-      next,
-      JUNIOR_THREAD_STATE_TTL_MS
-    );
-  } finally {
-    await state.releaseLock(lock);
-  }
-}
-async function getDispatchRecord(id) {
-  const state = getStateAdapter();
-  await state.connect();
-  return parseDispatchRecord(await state.get(getDispatchStorageKey(id)));
-}
-async function createOrGetDispatch(args) {
-  const id = buildDispatchId(args.plugin, args.options.idempotencyKey);
-  return await withDispatchLock(id, async (state) => {
-    const existing = parseDispatchRecord(
-      await state.get(getDispatchStorageKey(id))
-    );
-    if (existing) {
-      return { record: existing, status: "already_exists" };
-    }
-    const metadata = normalizeMetadata(args.options.metadata);
-    const record = {
-      actor: { platform: "system", name: args.plugin },
-      createdAtMs: args.nowMs,
-      ...args.options.credentialSubject ? { credentialSubject: args.options.credentialSubject } : {},
-      destination: args.options.destination,
-      destinationVisibility: args.options.destinationVisibility,
-      id,
-      idempotencyKey: args.options.idempotencyKey,
-      input: args.options.input,
-      ...metadata ? { metadata } : {},
-      plugin: args.plugin,
-      ...args.options.replyAttribution ? { replyAttribution: args.options.replyAttribution } : {},
-      status: "pending",
-      source: args.options.source,
-      updatedAtMs: args.nowMs
-    };
-    await updatePendingDispatchMailboxAppendIndex(
-      state,
-      (ids) => ids.includes(id) ? ids : [...ids, id]
-    );
-    await putRecord(state, record);
-    return { record, status: "created" };
-  });
-}
-async function transitionDispatch(id, transition) {
-  return await withDispatchLock(id, async (state) => {
-    const current = parseDispatchRecord(
-      await state.get(getDispatchStorageKey(id))
-    );
-    if (!current) {
-      return void 0;
-    }
-    const transitioned = transition(current);
-    if (transitioned === current) {
-      return current;
-    }
-    const next = {
-      ...transitioned,
-      updatedAtMs: Date.now()
-    };
-    await putRecord(state, next);
-    return next;
-  });
-}
-async function markDispatchRunning(id) {
-  return await transitionDispatch(
-    id,
-    (record) => isTerminalDispatchStatus(record.status) ? record : { ...record, status: "running", errorMessage: void 0 }
-  );
-}
-async function markDispatchAwaitingResume(id) {
-  return await transitionDispatch(
-    id,
-    (record) => isTerminalDispatchStatus(record.status) ? record : {
-      ...record,
-      status: "awaiting_resume"
-    }
-  );
-}
-async function markDispatchBlocked(id, errorMessage, resultMessageTs) {
-  return await transitionDispatch(
-    id,
-    (record) => isTerminalDispatchStatus(record.status) ? record : {
-      ...record,
-      errorMessage,
-      ...resultMessageTs ? { resultMessageTs } : {},
-      status: "blocked"
-    }
-  );
-}
-async function markDispatchCompleted(id, resultMessageTs) {
-  const previous = await getDispatchRecord(id);
-  const next = await transitionDispatch(
-    id,
-    (record) => isTerminalDispatchStatus(record.status) ? record : {
-      ...record,
-      errorMessage: void 0,
-      ...resultMessageTs ? { resultMessageTs } : {},
-      status: "completed"
-    }
-  );
-  if (next?.status === "completed" && previous?.status !== "completed" && next.plugin === "junior") {
-    const eventTaskId = next.metadata?.eventTaskId;
-    if (eventTaskId) {
-      await recordTaskExecution("event", eventTaskId, {
-        conversationId: getDispatchConversationId(next),
-        executionId: next.id,
-        nowMs: next.updatedAtMs
-      });
-    }
-  }
-  return next;
-}
-async function markDispatchFailed(id, errorMessage, resultMessageTs) {
-  return await transitionDispatch(
-    id,
-    (record) => isTerminalDispatchStatus(record.status) ? record : {
-      ...record,
-      errorMessage,
-      ...resultMessageTs ? { resultMessageTs } : {},
-      status: "failed"
-    }
-  );
-}
-async function confirmDispatchMailboxAppend(id) {
-  const state = getStateAdapter();
-  await state.connect();
-  await updatePendingDispatchMailboxAppendIndex(
-    state,
-    (ids) => ids.filter((candidate) => candidate !== id)
-  );
-}
-async function listPendingDispatchMailboxAppends() {
-  const state = getStateAdapter();
-  await state.connect();
-  const stored = await state.get(pendingDispatchMailboxAppendIndexKey());
-  return stored === void 0 || stored === null ? [] : [...new Set(pendingDispatchMailboxAppendIndexSchema.parse(stored))];
-}
-async function claimDispatchMailboxAppend(id, nowMs) {
-  return await withDispatchLock(id, async (state) => {
-    const stored = parseStoredDispatchRecord(
-      await state.get(getDispatchStorageKey(id))
-    );
-    if (!stored || stored.legacyLeaseExpiresAtMs && stored.legacyLeaseExpiresAtMs > nowMs) {
-      return void 0;
-    }
-    await putRecord(state, stored.record);
-    return stored.record;
-  });
-}
-async function getPluginDispatchProjection(args) {
-  const record = await getDispatchRecord(args.id);
-  if (!record || record.plugin !== args.plugin) {
-    return void 0;
-  }
-  return toDispatchProjection(record);
-}
-
 // src/chat/agent-dispatch/work.ts
-import { z as z3 } from "zod";
-var agentDispatchMailboxMetadataSchema = z3.object({
-  dispatchId: z3.string().min(1),
-  kind: z3.literal("agent_dispatch")
+import { z as z2 } from "zod";
+var agentDispatchMailboxMetadataSchema = z2.object({
+  dispatchId: z2.string().min(1),
+  kind: z2.literal("agent_dispatch")
 }).strict();
 var AGENT_DISPATCH_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 function buildDispatchRoutingContext(dispatch2) {
   return {
     actor: dispatch2.actor,
-    credentialContext: {
-      actor: dispatch2.actor,
-      ...dispatch2.credentialSubject ? { subject: dispatch2.credentialSubject } : {}
-    },
+    credentialContext: credentialContextForActor(
+      dispatch2.actor,
+      dispatch2.credentialSubject
+    ),
     destinationVisibility: dispatch2.destinationVisibility,
     dispatch: {
       actor: dispatch2.actor,
@@ -1301,7 +939,7 @@ import {
 // src/chat/agent-dispatch/validation.ts
 import {
   dispatchOptionsSchema,
-  isSlackDestination as isSlackDestination2
+  isSlackDestination
 } from "@sentry/junior-plugin-api";
 function hasIssueAtPath(issues, path) {
   return issues.some(
@@ -1398,7 +1036,7 @@ function validateDispatchOptions(options) {
   }
   const candidate = parsed.data;
   const { credentialSubject, destination } = candidate;
-  if (!isSlackDestination2(destination)) {
+  if (!isSlackDestination(destination)) {
     throw new Error("Dispatch destination platform must be slack");
   }
   if (credentialSubject !== void 0) {
@@ -1623,6 +1261,37 @@ function shouldSkipRun(task, run) {
   }
   return void 0;
 }
+async function recordScheduledExecution(args) {
+  const dispatchId = args.run.dispatchId;
+  await recordTaskExecution("scheduled", args.run.taskId, {
+    ...dispatchId ? { conversationId: getDispatchConversationId({ id: dispatchId }) } : {},
+    executionId: args.run.id,
+    nowMs: args.nowMs,
+    status: args.status
+  });
+}
+async function logRunOutcome(args) {
+  const task = args.task ?? await args.store.getTask(args.run.taskId) ?? void 0;
+  if (!task) {
+    logInfo(args.eventName, {
+      "app.task.id": args.run.taskId,
+      "app.task.type": "scheduled",
+      "app.task.run.id": args.run.id,
+      "app.task.run.status": args.run.status,
+      "app.task.run.scheduled_for": new Date(
+        args.run.scheduledForMs
+      ).toISOString(),
+      ...args.run.dispatchId ? { "app.dispatch.id": args.run.dispatchId } : {},
+      ...args.run.resultMessageTs ? { "app.task.result_message_ts": args.run.resultMessageTs } : {},
+      ...args.extras
+    });
+    return;
+  }
+  logInfo(
+    args.eventName,
+    scheduledTaskRunAttributes(task, args.run, args.extras)
+  );
+}
 async function applyDispatchResult(args) {
   if (args.dispatch.status === "completed") {
     const completed = await args.store.markRunCompleted({
@@ -1637,14 +1306,16 @@ async function applyDispatchResult(args) {
       run: args.run,
       status: "completed"
     });
-    const dispatchId = args.run.dispatchId;
-    if (dispatchId) {
-      await recordTaskExecution("scheduled", args.run.taskId, {
-        conversationId: getDispatchConversationId({ id: dispatchId }),
-        executionId: args.run.id,
-        nowMs: args.nowMs
-      });
-    }
+    await recordScheduledExecution({
+      nowMs: args.nowMs,
+      run: args.run,
+      status: "completed"
+    });
+    await logRunOutcome({
+      eventName: "scheduled_task.run.completed",
+      run: completed,
+      store: args.store
+    });
     return true;
   }
   if (args.dispatch.status === "blocked") {
@@ -1661,6 +1332,17 @@ async function applyDispatchResult(args) {
       run: args.run,
       status: "blocked"
     });
+    await recordScheduledExecution({
+      nowMs: args.nowMs,
+      run: args.run,
+      status: "blocked"
+    });
+    await logRunOutcome({
+      eventName: "scheduled_task.run.blocked",
+      run: blocked,
+      store: args.store,
+      extras: blocked.errorMessage ? { "app.task.run.error": blocked.errorMessage } : void 0
+    });
     return true;
   }
   if (args.dispatch.status === "failed") {
@@ -1677,6 +1359,17 @@ async function applyDispatchResult(args) {
       run: args.run,
       status: "failed"
     });
+    await recordScheduledExecution({
+      nowMs: args.nowMs,
+      run: args.run,
+      status: "failed"
+    });
+    await logRunOutcome({
+      eventName: "scheduled_task.run.failed",
+      run: failed,
+      store: args.store,
+      extras: failed.errorMessage ? { "app.task.run.error": failed.errorMessage } : void 0
+    });
     return true;
   }
   return false;
@@ -1699,6 +1392,17 @@ async function finishClaimedRun(args) {
     run: args.run,
     status: args.status
   });
+  await recordScheduledExecution({
+    nowMs: args.nowMs,
+    run: args.run,
+    status: args.status
+  });
+  await logRunOutcome({
+    eventName: args.status === "blocked" ? "scheduled_task.run.blocked" : "scheduled_task.run.failed",
+    run: finished,
+    store: args.store,
+    extras: { "app.task.run.error": args.errorMessage }
+  });
 }
 async function runScheduledTaskHeartbeat(args) {
   const store = createSchedulerSqlStore(getDb());
@@ -1717,7 +1421,12 @@ async function runScheduledTaskHeartbeat(args) {
       });
       continue;
     }
-    if (await applyDispatchResult({ dispatch: dispatch2, nowMs: args.nowMs, run, store })) {
+    if (await applyDispatchResult({
+      dispatch: dispatch2,
+      nowMs: args.nowMs,
+      run,
+      store
+    })) {
       processedCount += 1;
     }
   }
@@ -1726,20 +1435,39 @@ async function runScheduledTaskHeartbeat(args) {
     if (!run) break;
     const task = await store.getTask(run.taskId);
     if (!task) {
-      await store.markRunFailed({
+      const failed = await store.markRunFailed({
         completedAtMs: args.nowMs,
         errorMessage: `Scheduled task ${run.taskId} was not found`,
         runId: run.id
       });
+      if (failed) {
+        await logRunOutcome({
+          eventName: "scheduled_task.run.failed",
+          run: failed,
+          store,
+          extras: {
+            "app.task.run.error": `Scheduled task ${run.taskId} was not found`
+          }
+        });
+      }
       continue;
     }
+    logInfo(
+      "scheduled_task.run.claimed",
+      scheduledTaskRunAttributes(task, run)
+    );
     const skippedReason = shouldSkipRun(task, run);
     if (skippedReason) {
-      await store.markRunSkipped({
+      const skipped = await store.markRunSkipped({
         completedAtMs: args.nowMs,
         errorMessage: skippedReason,
         runId: run.id
       });
+      if (skipped) {
+        logScheduledTaskRunSkipped(task, skipped, {
+          "app.task.run.error": skippedReason
+        });
+      }
       continue;
     }
     let metadata;
@@ -1788,12 +1516,22 @@ async function runScheduledTaskHeartbeat(args) {
       });
       continue;
     }
-    await store.markRunDispatched({
+    const dispatched = await store.markRunDispatched({
       claimedAtMs: run.claimedAtMs,
       dispatchId: dispatch2.id,
       nowMs: args.nowMs,
       runId: run.id
     });
+    logInfo(
+      "scheduled_task.run.dispatched",
+      scheduledTaskRunAttributes(
+        task,
+        dispatched ?? { ...run, dispatchId: dispatch2.id },
+        {
+          "app.dispatch.id": dispatch2.id
+        }
+      )
+    );
     dispatchCount += 1;
   }
   return dispatchCount;
@@ -2658,7 +2396,7 @@ import {
   Message,
   ThreadImpl
 } from "chat";
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 
 // src/chat/ingress/message-router.ts
 function normalizeIncomingSlackThreadId(threadId, message) {
@@ -2829,14 +2567,14 @@ async function ensureSlackMessageActorIdentity(message, teamId, lookupSlackUser2
 }
 
 // src/chat/slack/user.ts
-import { z as z4 } from "zod";
-var slackUserInfoSchema = z4.object({
-  ok: z4.literal(true),
-  user: z4.object({
-    name: z4.string().nullish(),
-    profile: z4.object({
-      email: z4.string().nullish(),
-      real_name: z4.string().nullish()
+import { z as z3 } from "zod";
+var slackUserInfoSchema = z3.object({
+  ok: z3.literal(true),
+  user: z3.object({
+    name: z3.string().nullish(),
+    profile: z3.object({
+      email: z3.string().nullish(),
+      real_name: z3.string().nullish()
     }).optional()
   })
 });
@@ -2913,6 +2651,20 @@ async function lookupSlackUser(teamId, userId) {
   }
 }
 
+// src/chat/resource-events/actor.ts
+var RESOURCE_EVENT_SLACK_AUTHOR_ID = "UJRNEVENT";
+var RESOURCE_EVENT_SYSTEM_ACTOR = {
+  platform: "system",
+  name: "resource-event"
+};
+function isResourceEventConversationMessage(message) {
+  return Boolean(message.meta?.eventType) || message.author?.userId === RESOURCE_EVENT_SLACK_AUTHOR_ID;
+}
+function isResourceEventSlackMessage(message) {
+  const raw = message.raw && typeof message.raw === "object" ? message.raw : void 0;
+  return raw?.event_type === "resource_event";
+}
+
 // src/chat/slack/message-control.ts
 var LEADING_MENTION_BEFORE_STEERING_RE = /^(\s*(?:<@[^>]+>|@[A-Za-z0-9._-]+\b)[\s,:-]*)!!\s*/;
 function stripLeadingSteeringOverride(text) {
@@ -2920,17 +2672,17 @@ function stripLeadingSteeringOverride(text) {
 }
 
 // src/chat/task-execution/slack-work.ts
-var slackConversationRouteSchema = z5.enum(["mention", "subscribed"]);
+var slackConversationRouteSchema = z4.enum(["mention", "subscribed"]);
 function hasSteeringOverride(text) {
   return stripLeadingSteeringOverride(text) !== text;
 }
-var serializedDateSchema = z5.iso.datetime();
-var mdastPointSchema = z5.object({
-  column: z5.number().int().positive(),
-  line: z5.number().int().positive(),
-  offset: z5.number().int().nonnegative().optional()
+var serializedDateSchema = z4.iso.datetime();
+var mdastPointSchema = z4.object({
+  column: z4.number().int().positive(),
+  line: z4.number().int().positive(),
+  offset: z4.number().int().nonnegative().optional()
 }).strict();
-var mdastPositionSchema = z5.object({
+var mdastPositionSchema = z4.object({
   end: mdastPointSchema,
   start: mdastPointSchema
 }).strict();
@@ -3042,7 +2794,7 @@ function isFormattedContentNode(value) {
       return false;
   }
 }
-var formattedContentSchema = z5.custom(
+var formattedContentSchema = z4.custom(
   (value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
       return false;
@@ -3052,79 +2804,79 @@ var formattedContentSchema = z5.custom(
   },
   "must be a valid formatted-content root"
 );
-var serializedMessageSchema = z5.object({
-  _type: z5.literal("chat:Message"),
-  attachments: z5.array(
-    z5.object({
-      type: z5.enum(["image", "file", "video", "audio"]),
-      url: z5.string().optional(),
-      name: z5.string().optional(),
-      mimeType: z5.string().optional(),
-      size: z5.number().finite().optional(),
-      width: z5.number().finite().optional(),
-      height: z5.number().finite().optional(),
-      fetchMetadata: z5.record(z5.string(), z5.string()).optional()
+var serializedMessageSchema = z4.object({
+  _type: z4.literal("chat:Message"),
+  attachments: z4.array(
+    z4.object({
+      type: z4.enum(["image", "file", "video", "audio"]),
+      url: z4.string().optional(),
+      name: z4.string().optional(),
+      mimeType: z4.string().optional(),
+      size: z4.number().finite().optional(),
+      width: z4.number().finite().optional(),
+      height: z4.number().finite().optional(),
+      fetchMetadata: z4.record(z4.string(), z4.string()).optional()
     }).strict()
   ),
-  author: z5.object({
-    userId: z5.string(),
-    userName: z5.string(),
-    fullName: z5.string(),
-    isBot: z5.union([z5.boolean(), z5.literal("unknown")]),
-    isMe: z5.boolean()
+  author: z4.object({
+    userId: z4.string(),
+    userName: z4.string(),
+    fullName: z4.string(),
+    isBot: z4.union([z4.boolean(), z4.literal("unknown")]),
+    isMe: z4.boolean()
   }).strict(),
   formatted: formattedContentSchema,
-  id: z5.string().min(1),
-  isMention: z5.boolean().optional(),
-  links: z5.array(
-    z5.object({
-      url: z5.string(),
-      title: z5.string().optional(),
-      description: z5.string().optional(),
-      imageUrl: z5.string().optional(),
-      siteName: z5.string().optional()
+  id: z4.string().min(1),
+  isMention: z4.boolean().optional(),
+  links: z4.array(
+    z4.object({
+      url: z4.string(),
+      title: z4.string().optional(),
+      description: z4.string().optional(),
+      imageUrl: z4.string().optional(),
+      siteName: z4.string().optional()
     }).strict()
   ).optional(),
-  metadata: z5.object({
+  metadata: z4.object({
     dateSent: serializedDateSchema,
-    edited: z5.boolean(),
+    edited: z4.boolean(),
     editedAt: serializedDateSchema.optional()
   }).strict(),
-  raw: z5.unknown(),
-  text: z5.string(),
-  threadId: z5.string().min(1)
+  raw: z4.unknown(),
+  text: z4.string(),
+  threadId: z4.string().min(1)
 }).strict();
-var serializedThreadSchema = z5.object({
-  _type: z5.literal("chat:Thread"),
-  adapterName: z5.literal("slack"),
-  channelId: z5.string().min(1),
-  channelVisibility: z5.enum(["private", "workspace", "external", "unknown"]).optional(),
+var serializedThreadSchema = z4.object({
+  _type: z4.literal("chat:Thread"),
+  adapterName: z4.literal("slack"),
+  channelId: z4.string().min(1),
+  channelVisibility: z4.enum(["private", "workspace", "external", "unknown"]).optional(),
   currentMessage: serializedMessageSchema.optional(),
-  id: z5.string().min(1),
-  isDM: z5.boolean()
+  id: z4.string().min(1),
+  isDM: z4.boolean()
 }).strict();
-var slackInstallationSchema = z5.object({
-  enterpriseId: z5.string().optional(),
-  isEnterpriseInstall: z5.boolean().optional(),
-  teamId: z5.string().optional()
+var slackInstallationSchema = z4.object({
+  enterpriseId: z4.string().optional(),
+  isEnterpriseInstall: z4.boolean().optional(),
+  teamId: z4.string().optional()
 }).strict();
-var slackConversationMessageMetadataBaseSchema = z5.object({
+var slackConversationMessageMetadataBaseSchema = z4.object({
   installation: slackInstallationSchema.optional(),
   message: serializedMessageSchema,
-  platform: z5.literal("slack"),
+  platform: z4.literal("slack"),
   route: slackConversationRouteSchema,
   thread: serializedThreadSchema
 });
-var slackConversationMessageMetadataSchema = z5.union([
+var slackConversationMessageMetadataSchema = z4.union([
   slackConversationMessageMetadataBaseSchema.strict(),
   slackConversationMessageMetadataBaseSchema.extend({
-    kind: z5.literal("resource_event"),
-    resourceEvent: z5.object({
-      eventKey: z5.string(),
-      eventType: z5.string(),
-      namespace: z5.string(),
-      identifier: z5.string(),
-      subscriptionId: z5.string()
+    kind: z4.literal("resource_event"),
+    resourceEvent: z4.object({
+      eventKey: z4.string(),
+      eventType: z4.string(),
+      namespace: z4.string(),
+      identifier: z4.string(),
+      subscriptionId: z4.string()
     }).strict()
   }).strict()
 ]);
@@ -3157,7 +2909,7 @@ function slackSerializedResourceEventMessage(input) {
     _type: "chat:Message",
     attachments: [],
     author: {
-      userId: "UJRNEVENT",
+      userId: RESOURCE_EVENT_SLACK_AUTHOR_ID,
       userName: "junior-event",
       fullName: "Junior event",
       isBot: true,
@@ -3175,7 +2927,7 @@ function slackSerializedResourceEventMessage(input) {
       resource_event_type: input.eventType,
       thread_ts: input.threadTs,
       type: "message",
-      user: "UJRNEVENT"
+      user: RESOURCE_EVENT_SLACK_AUTHOR_ID
     },
     text: input.text,
     threadId: `slack:${input.channelId}:${input.threadTs}`
@@ -3219,7 +2971,7 @@ function createSlackResourceEventInboundMessage(input) {
     receivedAtMs: Date.now(),
     input: {
       text: input.text,
-      authorId: "UJRNEVENT",
+      authorId: RESOURCE_EVENT_SLACK_AUTHOR_ID,
       metadata: {
         kind: "resource_event",
         installation: {
@@ -3259,10 +3011,6 @@ function routeForRecords(records) {
     return metadata.route === "mention";
   }) ? "mention" : "subscribed";
 }
-function isResourceEventNotificationMessage(message) {
-  const raw = message.raw && typeof message.raw === "object" ? message.raw : void 0;
-  return raw?.event_type === "resource_event";
-}
 function restoreMessage(args) {
   const metadata = parseSlackMetadata(args.record.input.metadata);
   if (!metadata) {
@@ -3278,7 +3026,7 @@ function restoreMessage(args) {
 async function bindSlackActorIdentities(args) {
   const byAuthorId = /* @__PURE__ */ new Map();
   for (const message of args.messages) {
-    if (isResourceEventNotificationMessage(message)) {
+    if (isResourceEventSlackMessage(message)) {
       continue;
     }
     const authorId = requireSlackAuthorId(message);
@@ -4497,7 +4245,7 @@ function registerVercelPluginTaskDevConsumer() {
 }
 
 // src/chat/services/subscribed-decision.ts
-import { z as z6 } from "zod";
+import { z as z5 } from "zod";
 
 // src/chat/services/subscribed-reply-router-policy.ts
 function buildSubscribedReplyRouterPolicy(assistantName) {
@@ -4542,13 +4290,13 @@ Assess conversation floor ownership and whether the latest message continues wor
 }
 
 // src/chat/services/subscribed-decision.ts
-var replyDecisionSchema = z6.object({
-  should_reply: z6.boolean().describe("Whether Junior should respond to this thread message."),
-  should_unsubscribe: z6.boolean().describe(
+var replyDecisionSchema = z5.object({
+  should_reply: z5.boolean().describe("Whether Junior should respond to this thread message."),
+  should_unsubscribe: z5.boolean().describe(
     "Whether Junior should unsubscribe from this thread because the user clearly asked it to stop participating."
   ),
-  confidence: z6.number().min(0).max(1).describe("Classifier confidence from 0 to 1."),
-  reason: z6.string().describe("Short reason for the decision; use an empty string if none.")
+  confidence: z5.number().min(0).max(1).describe("Classifier confidence from 0 to 1."),
+  reason: z5.string().describe("Short reason for the decision; use an empty string if none.")
 }).strict();
 var ROUTER_CONFIDENCE_THRESHOLD = 0.7;
 var ROUTER_CLASSIFIER_MAX_TOKENS = 400;
@@ -5003,10 +4751,6 @@ function buildLogContext(deps, args) {
 function actorUserName(message) {
   return getMessageActorIdentity(message)?.userName;
 }
-function isResourceEventNotificationMessage2(message) {
-  const raw = message.raw && typeof message.raw === "object" ? message.raw : void 0;
-  return raw?.event_type === "resource_event";
-}
 function createSlackTurnRuntime(deps) {
   const logContext = (args) => buildLogContext(deps, args);
   const maybeHandleThreadOptOutDecision = async (args) => {
@@ -5427,7 +5171,7 @@ function createSlackTurnRuntime(deps) {
         const threadId = deps.getThreadId(thread, message);
         const channelId = deps.getChannelId(thread, message);
         const runId = deps.getRunId(thread, message);
-        const isResourceEventNotification = isResourceEventNotificationMessage2(message);
+        const isResourceEventNotification = isResourceEventSlackMessage(message);
         const actorId = isResourceEventNotification ? void 0 : message.author.userId;
         const turnContext = logContext({
           threadId,
@@ -6225,11 +5969,11 @@ function createJuniorRuntimeServices(overrides = {}) {
 import { createSlackSource as createSlackSource2 } from "@sentry/junior-plugin-api";
 
 // src/chat/slack/action-token.ts
-import { z as z7 } from "zod";
-var slackActionTokenSchema = z7.string().trim().min(1).brand();
-var slackMessageEnvelopeSchema = z7.object({
-  raw: z7.object({
-    action_token: z7.unknown().optional()
+import { z as z6 } from "zod";
+var slackActionTokenSchema = z6.string().trim().min(1).brand();
+var slackMessageEnvelopeSchema = z6.object({
+  raw: z6.object({
+    action_token: z6.unknown().optional()
   }).optional()
 });
 function readSlackActionToken(message) {
@@ -6393,7 +6137,7 @@ function queuedInstructionActor(queued) {
   };
 }
 function queuedInstructionProvenance(queued, teamId) {
-  if (isResourceEventMessage(queued.message)) {
+  if (isResourceEventSlackMessage(queued.message)) {
     return contextProvenance;
   }
   const identity = getMessageActorIdentity(queued.message);
@@ -6407,13 +6151,6 @@ function queuedInstructionProvenance(queued, teamId) {
   );
   return instructionProvenanceFor(author);
 }
-function isResourceEventMessage(message) {
-  const raw = message.raw && typeof message.raw === "object" ? message.raw : void 0;
-  return raw?.event_type === "resource_event";
-}
-function resourceEventCredentialContext(message) {
-  return isResourceEventMessage(message) ? { actor: { platform: "system", name: "resource-event" } } : void 0;
-}
 async function resolveChannelName(thread) {
   const existingName = thread.channel.name?.trim();
   if (existingName) {
@@ -6542,7 +6279,7 @@ function createReplyToThread(deps) {
           )
         };
         await Promise.all(
-          (options.queuedMessages ?? []).filter((queued) => !isResourceEventMessage(queued.message)).map(
+          (options.queuedMessages ?? []).filter((queued) => !isResourceEventSlackMessage(queued.message)).map(
             (queued) => ensureSlackMessageActorIdentity(
               queued.message,
               teamId,
@@ -6551,15 +6288,28 @@ function createReplyToThread(deps) {
           )
         );
         const effectiveUserText = currentText.userText;
-        const credentialContext = options.execution?.credentialContext ?? resourceEventCredentialContext(message) ?? {
-          actor: { type: "user", userId: message.author.userId }
-        };
-        const actor = "type" in credentialContext.actor ? await ensureSlackMessageActorIdentity(
-          message,
-          teamId,
-          deps.services.lookupSlackUser
-        ) : void 0;
-        const executionActor = "type" in credentialContext.actor ? actor : credentialContext.actor;
+        let executionActor;
+        let credentialContext;
+        if (options.execution) {
+          executionActor = options.execution.dispatch.actor;
+          credentialContext = options.execution.credentialContext;
+        } else if (isResourceEventSlackMessage(message)) {
+          executionActor = RESOURCE_EVENT_SYSTEM_ACTOR;
+          credentialContext = credentialContextForActor(executionActor);
+        } else {
+          executionActor = await ensureSlackMessageActorIdentity(
+            message,
+            teamId,
+            deps.services.lookupSlackUser
+          );
+          if (executionActor) {
+            credentialContext = credentialContextForActor(executionActor);
+          }
+        }
+        if (!executionActor || !credentialContext) {
+          throw new Error("Slack reply execution requires an actor");
+        }
+        const actor = "userId" in executionActor ? executionActor : void 0;
         const slackActorId = actor?.userId;
         const preparedState = options.preparedState ?? await deps.prepareTurnState({
           thread,
@@ -6633,7 +6383,7 @@ function createReplyToThread(deps) {
                   attachments,
                   {
                     threadId,
-                    actorId: isResourceEventMessage(queued.message) ? void 0 : queued.message.author.userId,
+                    actorId: isResourceEventSlackMessage(queued.message) ? void 0 : queued.message.author.userId,
                     channelId,
                     runId,
                     conversation: preparedState.conversation,
@@ -7208,7 +6958,9 @@ function createReplyToThread(deps) {
             },
             routing: {
               credentialContext,
-              actor: options.execution ? executionActor : actor,
+              // Always set the execution actor when known. Resource-event turns
+              // carry the system principal; interactive turns carry the Slack user.
+              actor: executionActor,
               slackConversation,
               source,
               destination,
@@ -8236,27 +7988,57 @@ async function failContinuationStartup(args) {
     );
   }
 }
-async function resolveContinuationActor(args) {
-  const stored = args.sessionRecordActor;
-  if (stored?.platform === "slack" && stored.teamId === args.teamId && stored.userId === args.userId) {
+async function resolveSlackResumeUserActor(args) {
+  try {
+    const work = await getConversationWorkState({
+      conversationId: args.conversationId
+    });
+    const workActor = work?.actor;
+    if (workActor?.teamId === args.teamId && workActor.slackUserId === args.userId) {
+      try {
+        return createSlackActor(args.teamId, args.userId, {
+          email: workActor.email,
+          fullName: workActor.fullName,
+          userName: workActor.slackUserName
+        });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  try {
     return createSlackResumeActor({
-      actor: stored,
       teamId: args.teamId,
       userId: args.userId
     });
+  } catch {
+    return void 0;
   }
-  const work = await getConversationWorkState({
-    conversationId: args.conversationId
-  });
-  const workActor = work?.actor;
-  if (workActor && workActor.teamId === args.teamId && workActor.slackUserId === args.userId) {
-    return createSlackActor(args.teamId, args.userId, {
-      email: workActor.email,
-      fullName: workActor.fullName,
-      userName: workActor.slackUserName
+}
+async function resolveResumeExecutionIdentity(args) {
+  const routing = args.routingContext;
+  if (routing?.credentialContext) {
+    const actor2 = routing.dispatch?.actor ?? routing.actor ?? (!("type" in routing.credentialContext.actor) ? routing.credentialContext.actor : void 0);
+    return actor2 ? { actor: actor2, credentialContext: routing.credentialContext } : void 0;
+  }
+  let actor = routing?.actor;
+  if (!actor && isResourceEventConversationMessage(args.userMessage)) {
+    actor = RESOURCE_EVENT_SYSTEM_ACTOR;
+  }
+  if (!actor && args.userMessage.author?.userId) {
+    actor = await resolveSlackResumeUserActor({
+      conversationId: args.conversationId,
+      teamId: args.teamId,
+      userId: args.userMessage.author.userId
     });
   }
-  return void 0;
+  if (!actor) {
+    return void 0;
+  }
+  return {
+    actor,
+    credentialContext: credentialContextForActor(actor)
+  };
 }
 function isContinuationResume(summary) {
   return summary.state === "awaiting_resume" && (summary.resumeReason === "timeout" || summary.resumeReason === "yield" || summary.resumeReason === "retry");
@@ -8274,7 +8056,6 @@ async function failUnresumableContinuation(args) {
         conversationId: args.conversationId
       });
       await recordAgentTurnSessionSummary({
-        actor: args.summary.actor,
         conversationId: args.conversationId,
         destination: routing.destination,
         dispatchId: args.summary.dispatchId,
@@ -8341,16 +8122,32 @@ async function continueSlackAgentRunInContext(payload, options, runOptions) {
           (message) => message.role === "user" && options.inputMessageIds?.includes(message.id)
         ) : void 0;
         const userMessage = getTurnUserMessage(conversation, payload.sessionId) ?? dispatchUserMessage;
-        const systemActor = activeSessionRecord.actor?.platform === "system" ? activeSessionRecord.actor : void 0;
-        const userActorId = userMessage?.author?.userId;
-        if (!userMessage || !systemActor && !userActorId) {
-          throw new Error(
-            `Unable to locate the persisted user message for agent continuation session "${payload.sessionId}"`
-          );
+        if (!userMessage) {
+          await failStrandedSessionWithFallback({
+            conversationId: payload.conversationId,
+            errorMessage: `Unable to locate the persisted user message for agent continuation session "${payload.sessionId}"`,
+            sessionRecord: activeSessionRecord
+          });
+          return false;
         }
         if (conversation.processing.activeTurnId !== payload.sessionId) {
           return false;
         }
+        const identity = await resolveResumeExecutionIdentity({
+          conversationId: payload.conversationId,
+          routingContext: options.routingContext,
+          teamId: destination.teamId,
+          userMessage
+        });
+        if (!identity) {
+          await failStrandedSessionWithFallback({
+            conversationId: payload.conversationId,
+            errorMessage: "Unable to rebuild Slack actor for continuation",
+            sessionRecord: activeSessionRecord
+          });
+          return false;
+        }
+        const { actor, credentialContext } = identity;
         const channelConfiguration = getChannelConfigurationServiceById(
           destination.channelId
         );
@@ -8358,34 +8155,6 @@ async function continueSlackAgentRunInContext(payload, options, runOptions) {
           excludeMessageId: userMessage.id
         });
         const sandboxRef = getPersistedSandboxState(currentState);
-        let actor;
-        let credentialContext;
-        if (options.routingContext?.credentialContext) {
-          credentialContext = options.routingContext.credentialContext;
-        } else if (systemActor) {
-          credentialContext = { actor: systemActor };
-        } else {
-          actor = await resolveContinuationActor({
-            conversationId: payload.conversationId,
-            sessionRecordActor: activeSessionRecord.actor,
-            teamId: destination.teamId,
-            userId: userActorId
-          });
-          if (!actor) {
-            await failStrandedSessionWithFallback({
-              conversationId: payload.conversationId,
-              errorMessage: "Stored Slack actor missing for continuation",
-              sessionRecord: activeSessionRecord
-            });
-            return false;
-          }
-          credentialContext = {
-            actor: {
-              type: "user",
-              userId: actor.userId
-            }
-          };
-        }
         const routing = await resolveTurnSessionRouting({
           conversationId: payload.conversationId
         });
@@ -8433,7 +8202,7 @@ async function continueSlackAgentRunInContext(payload, options, runOptions) {
             routing: {
               ...options.routingContext,
               credentialContext,
-              ...options.routingContext?.actor ?? actor ? { actor: options.routingContext?.actor ?? actor } : {},
+              actor,
               destination: routingDestination,
               source,
               toolChannelId: artifacts.assistantContextChannelId ?? destination.channelId
@@ -8554,7 +8323,6 @@ async function failStrandedSessionWithFallback(args) {
   }
   if (args.sessionRecord.dispatchId) {
     await recordAgentTurnSessionSummary({
-      actor: args.sessionRecord.actor,
       conversationId: args.conversationId,
       destination: routing.destination,
       dispatchId: args.sessionRecord.dispatchId,
@@ -8619,7 +8387,6 @@ async function recoverStrandedRunningSession(args) {
     messages: sessionRecord.piMessages,
     errorMessage: "Recovered running session after hard worker death",
     modelId,
-    actor: sessionRecord.actor,
     surface: sessionRecord.surface
   });
   if (!parked) {
@@ -8949,7 +8716,7 @@ async function ingestResourceEvent(input, options) {
 }
 
 // src/chat/event-tasks/ingest.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash } from "crypto";
 import {
   createSlackSource as createSlackSource3,
   RESOURCE_EVENT_SUMMARY_MAX_LENGTH,
@@ -8957,7 +8724,7 @@ import {
   resourceEventSchema as resourceEventSchema2
 } from "@sentry/junior-plugin-api";
 function eventTaskDispatchKey(taskId, namespace, eventKey) {
-  return `event-task:${createHash2("sha256").update(`${taskId}\0${namespace}\0${eventKey}`).digest("hex").slice(0, 32)}`;
+  return `event-task:${createHash("sha256").update(`${taskId}\0${namespace}\0${eventKey}`).digest("hex").slice(0, 32)}`;
 }
 function oneLine(value) {
   return value.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim().slice(0, 512);