@sentry/junior 0.115.0 → 0.116.1

package/dist/app.js

@@ -48,7 +48,7 @@ import {
   startConversationWork,
   startSlackProcessingReaction,
   stripLeadingBotMention
-} from "./chunk-YCLO7D7M.js";
+} from "./chunk-JPKGW6L6.js";
 import "./chunk-FA6POGLH.js";
 import {
   ConversationTurnLifecycleService,
@@ -63,15 +63,15 @@ import {
   processPluginTask,
   requireTurnFailureEventId,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-AGLQYELI.js";
+} from "./chunk-H35BDAUS.js";
 import {
   GET,
   conversationVisibilityFromSlackChannelType,
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext
-} from "./chunk-G5SX4UPR.js";
+} from "./chunk-KNCELO2M.js";
 import "./chunk-4CODA7P5.js";
-import "./chunk-6OPTF4BQ.js";
+import "./chunk-PE44LDDQ.js";
 import {
   ConversationQueueMessageRejectedError,
   conversationQueueMessageSchema,
@@ -79,22 +79,22 @@ import {
   isConversationQueueMessageRejectedError,
   resolveConversationWorkQueueTopic,
   verifyConversationQueueMessage
-} from "./chunk-MIAKQNYX.js";
+} from "./chunk-6ZK6FZIV.js";
 import {
   PLUGIN_TASK_QUEUE_TOPIC,
   createVercelQueueClient,
   verifyPluginTaskQueueMessage
-} from "./chunk-KNFROR7R.js";
+} from "./chunk-5I6ORJUY.js";
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-6V762AB4.js";
+} from "./chunk-2YYPXQNQ.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
   pluginCatalogConfigFromPluginSet,
   pluginRuntimeRegistrationsFromPluginSet
-} from "./chunk-SG5WAA7H.js";
+} from "./chunk-WKU7TY22.js";
 import {
   AuthorizationFlowDisabledError,
   PluginCredentialFailureError,
@@ -121,7 +121,7 @@ import {
   setConfigDefaults,
   shouldEmitDevAgentTrace,
   shouldPropagateSandboxEgressTrace
-} from "./chunk-43RYMWJ2.js";
+} from "./chunk-GDAXWEIJ.js";
 import "./chunk-DIB4GX3G.js";
 import {
   RetryableDeliveryError,
@@ -132,10 +132,9 @@ import {
   deleteMcpStoredOAuthCredentials,
   formatProviderLabel,
   postSlackMessage,
-  resolveBaseUrl,
   splitSlackReplyText,
   startOAuthFlow
-} from "./chunk-LYA2AB5G.js";
+} from "./chunk-CGXLCMWI.js";
 import {
   ConversationTurnBoundaryError,
   CooperativeTurnYieldError,
@@ -187,12 +186,11 @@ import {
   startActiveTurn,
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages,
-  turnHasReply,
   updateConversationStats,
   upsertConversationMessage
-} from "./chunk-CEYOL62C.js";
+} from "./chunk-RYFAVWP3.js";
 import "./chunk-HDSDCEPK.js";
-import "./chunk-PVZHG2XZ.js";
+import "./chunk-VBMMMVVQ.js";
 import "./chunk-MU6HHZEN.js";
 import "./chunk-PDO5BLNM.js";
 import "./chunk-UIE3R5XU.js";
@@ -209,11 +207,11 @@ import {
   validatePlugins,
   verifyScheduledTaskCredentialSubject,
   verifySlackDirectCredentialSubject
-} from "./chunk-RAVKCKXA.js";
+} from "./chunk-ZYHLNTC2.js";
 import {
   acquireActiveLock,
   getStateAdapter
-} from "./chunk-67CVNDJ7.js";
+} from "./chunk-7CSVG54J.js";
 import {
   SlackActionError,
   downloadPrivateSlackFile,
@@ -223,11 +221,10 @@ import {
   normalizeSlackConversationId,
   runWithSlackInstallationToken,
   runWithWorkspaceTeamId
-} from "./chunk-CWEZEPD4.js";
+} from "./chunk-FAEALXEH.js";
 import {
   contextProvenance,
   createSlackDestination,
-  destinationKey,
   getConversationEventStore,
   getConversationStore,
   getDb,
@@ -235,11 +232,11 @@ import {
   instructionProvenanceFor,
   requireSlackDestination,
   withConversationEventLock
-} from "./chunk-HWCQRGLL.js";
+} from "./chunk-BFYVIOTS.js";
 import {
   juniorConversationEvents,
   juniorConversations
-} from "./chunk-JQFJO5WH.js";
+} from "./chunk-RXRQJF7Y.js";
 import {
   sleep
 } from "./chunk-4ZNGQH7C.js";
@@ -260,18 +257,18 @@ import {
   modelIdForProfile,
   setSlackReactionConfig,
   standardModelId
-} from "./chunk-SYJT7AKB.js";
+} from "./chunk-CY7NXM32.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
 import {
   parseSlackThreadId
 } from "./chunk-FXOYURO4.js";
-import "./chunk-2QG4MZQ7.js";
+import "./chunk-DLLW5ITL.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-6FKLPVF3.js";
-import "./chunk-EW5MLKT5.js";
+} from "./chunk-OY2PQQ4P.js";
+import "./chunk-XA3VLFPK.js";
 import {
   credentialSubjectSchema
 } from "./chunk-W3U3YQYI.js";
@@ -297,7 +294,7 @@ import {
   setTags,
   withContext,
   withSpan
-} from "./chunk-NVUQSFWX.js";
+} from "./chunk-F3SWGSPG.js";
 import {
   toOptionalString
 } from "./chunk-OB42YVAE.js";
@@ -312,10 +309,10 @@ import "./chunk-B3IT5END.js";
 import "./chunk-3V7OFJZC.js";
 import {
   JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE
-} from "./chunk-TVE25LPW.js";
+} from "./chunk-WLT72MRP.js";
 import {
   JUNIOR_VERSION
-} from "./chunk-FHC4JUSF.js";
+} from "./chunk-N3C4XCRE.js";
 import "./chunk-MLKGABMK.js";
 
 // src/app.ts
@@ -325,13 +322,16 @@ import { Hono } from "hono";
 
 // src/chat/agent-dispatch/signing.ts
 import { createHmac, timingSafeEqual } from "crypto";
-var DISPATCH_CALLBACK_PATH = "/api/internal/agent-dispatch";
+import { z } from "zod";
 var DISPATCH_HMAC_CONTEXT = "junior.agent_dispatch.v1";
 var DISPATCH_SIGNATURE_VERSION = "v1";
 var DISPATCH_MAX_SKEW_MS = 5 * 60 * 1e3;
-var DISPATCH_CALLBACK_TIMEOUT_MS = 1e4;
 var DISPATCH_TIMESTAMP_HEADER = "x-junior-dispatch-timestamp";
 var DISPATCH_SIGNATURE_HEADER = "x-junior-dispatch-signature";
+var legacyDispatchCallbackSchema = z.object({
+  expectedVersion: z.number().int().positive(),
+  id: z.string().min(1)
+}).strict();
 function getDispatchSecret() {
   return process.env.JUNIOR_SECRET?.trim() || void 0;
 }
@@ -350,50 +350,6 @@ function timingSafeMatch(expected, actual) {
   }
   return timingSafeEqual(expectedBuffer, actualBuffer);
 }
-function parseDispatchCallback(value) {
-  if (!value || typeof value !== "object") {
-    return void 0;
-  }
-  const record = value;
-  if (typeof record.id !== "string" || typeof record.expectedVersion !== "number") {
-    return void 0;
-  }
-  return {
-    id: record.id,
-    expectedVersion: record.expectedVersion
-  };
-}
-async function scheduleDispatchCallback(callback) {
-  const baseUrl = resolveBaseUrl();
-  if (!baseUrl) {
-    throw new Error(
-      "Cannot determine base URL for agent dispatch callback (set JUNIOR_BASE_URL or deploy to Vercel)"
-    );
-  }
-  const secret = getDispatchSecret();
-  if (!secret) {
-    throw new Error(
-      "Cannot determine agent dispatch secret (set JUNIOR_SECRET)"
-    );
-  }
-  const body = JSON.stringify(callback);
-  const timestamp = Date.now().toString();
-  const response = await fetch(`${baseUrl}${DISPATCH_CALLBACK_PATH}`, {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      [DISPATCH_TIMESTAMP_HEADER]: timestamp,
-      [DISPATCH_SIGNATURE_HEADER]: signBody(secret, timestamp, body)
-    },
-    signal: AbortSignal.timeout(DISPATCH_CALLBACK_TIMEOUT_MS),
-    body
-  });
-  if (!response.ok) {
-    throw new Error(
-      `Agent dispatch callback failed with status ${response.status}`
-    );
-  }
-}
 async function verifyDispatchCallbackRequest(request) {
   const timestamp = request.headers.get(DISPATCH_TIMESTAMP_HEADER)?.trim() ?? "";
   const signature = request.headers.get(DISPATCH_SIGNATURE_HEADER)?.trim() ?? "";
@@ -411,7 +367,8 @@ async function verifyDispatchCallbackRequest(request) {
     return void 0;
   }
   try {
-    return parseDispatchCallback(JSON.parse(body));
+    const parsed = legacyDispatchCallbackSchema.safeParse(JSON.parse(body));
+    return parsed.success ? parsed.data : void 0;
   } catch {
     return void 0;
   }
@@ -425,17 +382,18 @@ import {
   isSlackDestination,
   sourceSchema
 } from "@sentry/junior-plugin-api";
-import { z } from "zod";
+import { z as z2 } from "zod";
 var DISPATCH_PREFIX = "junior:agent_dispatch";
 var DISPATCH_LOCK_TTL_MS = 10 * 60 * 1e3;
-var DISPATCH_INDEX_LOCK_TTL_MS = 1e4;
-var DISPATCH_INDEX_MAX_LENGTH = 1e4;
-var DEFAULT_MAX_ATTEMPTS = 5;
-var nonEmptyExactStringSchema = z.string().min(1).refine(
+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 incompleteDispatchIndexSchema = z.array(nonEmptyExactStringSchema);
-var dispatchStatusSchema = z.enum([
+var pendingDispatchMailboxAppendIndexSchema = z2.array(
+  nonEmptyExactStringSchema
+);
+var dispatchStatusSchema = z2.enum([
   "pending",
   "running",
   "awaiting_resume",
@@ -443,35 +401,30 @@ var dispatchStatusSchema = z.enum([
   "failed",
   "blocked"
 ]);
-var dispatchActorSchema = z.object({
-  platform: z.literal("system"),
+var dispatchActorSchema = z2.object({
+  platform: z2.literal("system"),
   name: nonEmptyExactStringSchema
 }).strict();
-var dispatchRecordSchema = z.object({
+var dispatchRecordSchema = z2.object({
   actor: dispatchActorSchema,
-  attempt: z.number().int().nonnegative(),
-  createdAtMs: z.number().finite(),
+  createdAtMs: z2.number().finite(),
   credentialSubject: credentialSubjectSchema.optional(),
   destination: destinationSchema,
   destinationVisibility: destinationVisibilitySchema,
-  errorMessage: z.string().optional(),
+  errorMessage: z2.string().optional(),
   id: nonEmptyExactStringSchema,
-  idempotencyKey: z.string().min(1),
-  input: z.string().min(1),
-  lastCallbackAtMs: z.number().finite().optional(),
-  leaseExpiresAtMs: z.number().finite().optional(),
-  maxAttempts: z.number().int().positive(),
-  metadata: z.record(z.string(), z.string()).optional(),
+  idempotencyKey: z2.string().min(1),
+  input: z2.string().min(1),
+  metadata: z2.record(z2.string(), z2.string()).optional(),
   plugin: nonEmptyExactStringSchema,
-  resultMessageTs: z.string().optional(),
+  resultMessageTs: z2.string().optional(),
   source: sourceSchema,
   status: dispatchStatusSchema,
-  updatedAtMs: z.number().finite(),
-  version: z.number().int().positive()
+  updatedAtMs: z2.number().finite()
 }).strict().superRefine((record, ctx) => {
   if (!isSlackDestination(record.destination)) {
     ctx.addIssue({
-      code: z.ZodIssueCode.custom,
+      code: z2.ZodIssueCode.custom,
       message: "Dispatch destination platform must be slack",
       path: ["destination"]
     });
@@ -484,7 +437,7 @@ var dispatchRecordSchema = z.object({
   if (subject.allowedWhen === "private-direct-conversation") {
     if (!record.destination.channelId.startsWith("D")) {
       ctx.addIssue({
-        code: z.ZodIssueCode.custom,
+        code: z2.ZodIssueCode.custom,
         message: "Dispatch credentialSubject requires a private direct Slack destination",
         path: ["credentialSubject"]
       });
@@ -492,7 +445,7 @@ var dispatchRecordSchema = z.object({
     }
     if (subject.binding.type !== "slack-direct-conversation" || subject.binding.teamId !== record.destination.teamId || subject.binding.channelId !== record.destination.channelId) {
       ctx.addIssue({
-        code: z.ZodIssueCode.custom,
+        code: z2.ZodIssueCode.custom,
         message: "Dispatch credentialSubject binding must match destination",
         path: ["credentialSubject", "binding"]
       });
@@ -501,27 +454,31 @@ var dispatchRecordSchema = z.object({
   }
   if (subject.binding.type !== "scheduled-task" || subject.binding.plugin !== record.plugin || subject.binding.taskId !== subject.taskId) {
     ctx.addIssue({
-      code: z.ZodIssueCode.custom,
+      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 incompleteDispatchIndexKey() {
+function dispatchLockKey(id) {
+  return `${DISPATCH_PREFIX}:lock:${id}`;
+}
+function pendingDispatchMailboxAppendIndexKey() {
   return `${DISPATCH_PREFIX}:incomplete`;
 }
-function incompleteDispatchIndexLockKey() {
+function pendingDispatchMailboxAppendIndexLockKey() {
   return `${DISPATCH_PREFIX}:incomplete:lock`;
 }
-function parseIncompleteDispatchIndex(value) {
-  return value === void 0 || value === null ? [] : incompleteDispatchIndexSchema.parse(value);
-}
-function dispatchLockKey(id) {
-  return `${DISPATCH_PREFIX}:lock:${id}`;
-}
 function normalizeMetadata(metadata) {
   if (!metadata) {
     return void 0;
@@ -536,15 +493,42 @@ function buildDispatchId(plugin, idempotencyKey) {
   return `dispatch_${digest}`;
 }
 function parseDispatchRecord(value) {
-  const parsed = dispatchRecordSchema.safeParse(value);
-  return parsed.success ? parsed.data : void 0;
+  const parsed = parseStoredDispatchRecord(value);
+  return parsed?.record;
 }
-function getDispatchDestinationLockId(destination) {
-  return destinationKey(destination);
+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(dispatch) {
   return `agent-dispatch:${dispatch.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}`;
 }
@@ -559,7 +543,7 @@ function toDispatchProjection(record) {
 function isTerminalDispatchStatus(status) {
   return status === "completed" || status === "failed" || status === "blocked";
 }
-async function withDispatchLock(dispatchId, callback) {
+async function withDispatchLock(dispatchId, task) {
   const state = getStateAdapter();
   await state.connect();
   const lock = await state.acquireLock(
@@ -570,45 +554,11 @@ async function withDispatchLock(dispatchId, callback) {
     throw new Error(`Could not acquire dispatch lock for ${dispatchId}`);
   }
   try {
-    return await callback(state);
+    return await task(state);
   } finally {
     await state.releaseLock(lock);
   }
 }
-async function withIncompleteDispatchIndexLock(state, callback) {
-  const lock = await state.acquireLock(
-    incompleteDispatchIndexLockKey(),
-    DISPATCH_INDEX_LOCK_TTL_MS
-  );
-  if (!lock) {
-    throw new Error("Could not acquire incomplete dispatch index lock");
-  }
-  try {
-    return await callback();
-  } finally {
-    await state.releaseLock(lock);
-  }
-}
-async function syncIncompleteDispatchIndex(state, record) {
-  await withIncompleteDispatchIndexLock(state, async () => {
-    const ids = [
-      ...new Set(
-        parseIncompleteDispatchIndex(
-          await state.get(incompleteDispatchIndexKey())
-        )
-      )
-    ];
-    const next = isTerminalDispatchStatus(record.status) ? ids.filter((id) => id !== record.id) : ids.includes(record.id) ? ids : [...ids, record.id];
-    if (next.length === ids.length && next.every((id, index) => id === ids[index])) {
-      return;
-    }
-    await state.set(
-      incompleteDispatchIndexKey(),
-      next.slice(-DISPATCH_INDEX_MAX_LENGTH),
-      JUNIOR_THREAD_STATE_TTL_MS
-    );
-  });
-}
 async function putRecord(state, record) {
   const parsed = dispatchRecordSchema.safeParse(record);
   if (!parsed.success) {
@@ -622,7 +572,32 @@ async function putRecord(state, record) {
     next,
     JUNIOR_THREAD_STATE_TTL_MS
   );
-  await syncIncompleteDispatchIndex(state, next);
+}
+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();
@@ -641,7 +616,6 @@ async function createOrGetDispatch(args) {
     const metadata = normalizeMetadata(args.options.metadata);
     const record = {
       actor: { platform: "system", name: args.plugin },
-      attempt: 0,
       createdAtMs: args.nowMs,
       ...args.options.credentialSubject ? { credentialSubject: args.options.credentialSubject } : {},
       destination: args.options.destination,
@@ -649,37 +623,113 @@ async function createOrGetDispatch(args) {
       id,
       idempotencyKey: args.options.idempotencyKey,
       input: args.options.input,
-      maxAttempts: DEFAULT_MAX_ATTEMPTS,
       ...metadata ? { metadata } : {},
       plugin: args.plugin,
       status: "pending",
       source: args.options.source,
-      updatedAtMs: args.nowMs,
-      version: 1
+      updatedAtMs: args.nowMs
     };
+    await updatePendingDispatchMailboxAppendIndex(
+      state,
+      (ids) => ids.includes(id) ? ids : [...ids, id]
+    );
     await putRecord(state, record);
     return { record, status: "created" };
   });
 }
-async function updateDispatchRecord(state, record) {
-  const next = {
-    ...record,
-    updatedAtMs: Date.now(),
-    version: record.version + 1
-  };
-  await putRecord(state, next);
-  return next;
+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 listIncompleteDispatchIds() {
+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) {
+  return await transitionDispatch(
+    id,
+    (record) => isTerminalDispatchStatus(record.status) ? record : {
+      ...record,
+      errorMessage: void 0,
+      ...resultMessageTs ? { resultMessageTs } : {},
+      status: "completed"
+    }
+  );
+}
+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();
-  return [
-    ...new Set(
-      parseIncompleteDispatchIndex(
-        await state.get(incompleteDispatchIndexKey())
-      )
-    )
-  ];
+  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);
@@ -689,487 +739,358 @@ async function getPluginDispatchProjection(args) {
   return toDispatchProjection(record);
 }
 
-// src/chat/agent-dispatch/runner.ts
-var DISPATCH_SLICE_LEASE_MS = 5 * 60 * 1e3;
-function getUserMessageId(dispatch) {
-  return `dispatch:${dispatch.id}:user`;
-}
-function buildDispatchConversationText(dispatch) {
-  return `[dispatched task] ${dispatch.input}`;
-}
-function upsertDispatchUserMessage(args) {
-  return upsertConversationMessage(args.conversation, {
-    id: getUserMessageId(args.dispatch),
-    role: "user",
-    text: normalizeConversationText(
-      buildDispatchConversationText(args.dispatch)
-    ),
-    createdAtMs: args.nowMs,
-    author: {
-      userName: `system:${args.dispatch.actor.name}`,
-      isBot: true
+// 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")
+}).strict();
+var AGENT_DISPATCH_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+function buildDispatchRoutingContext(dispatch) {
+  return {
+    actor: dispatch.actor,
+    credentialContext: {
+      actor: dispatch.actor,
+      ...dispatch.credentialSubject ? { subject: dispatch.credentialSubject } : {}
     },
-    meta: {
-      explicitMention: true
-    }
-  });
+    destinationVisibility: dispatch.destinationVisibility,
+    dispatch: {
+      actor: dispatch.actor,
+      id: dispatch.id,
+      metadata: dispatch.metadata,
+      plugin: dispatch.plugin
+    },
+    surface: "api"
+  };
 }
-async function persistRuntimePatch(args) {
-  await persistThreadStateById(args.threadId, {
-    artifacts: args.artifacts,
-    conversation: args.conversation,
-    sandboxRef: args.sandboxRef
-  });
+function buildAgentDispatchInboundMessage(dispatch, nowMs = Date.now()) {
+  return {
+    conversationId: getDispatchConversationId(dispatch),
+    createdAtMs: dispatch.createdAtMs,
+    delivery: "defer",
+    destination: dispatch.destination,
+    inboundMessageId: getDispatchInputMessageId(dispatch.id),
+    input: {
+      // The dispatch record is the idempotent request authority. The mailbox
+      // only signals which request this conversation lease may advance.
+      text: "[plugin dispatch]",
+      metadata: {
+        dispatchId: dispatch.id,
+        kind: "agent_dispatch"
+      }
+    },
+    receivedAtMs: nowMs,
+    source: "plugin"
+  };
 }
-async function markDispatch(args) {
-  return await withDispatchLock(args.dispatch.id, async (state) => {
-    const current = parseDispatchRecord(
-      await state.get(getDispatchStorageKey(args.dispatch.id))
-    );
-    if (!current) {
-      throw new Error("Dispatch record is missing or invalid.");
-    }
-    return await updateDispatchRecord(state, {
-      ...current,
-      status: args.status,
-      ...args.errorMessage ? { errorMessage: args.errorMessage } : {},
-      ...args.resultMessageTs ? { resultMessageTs: args.resultMessageTs } : {}
-    });
+async function enqueueAgentDispatch(dispatch, options) {
+  const nowMs = options.nowMs ?? Date.now();
+  const claimedDispatch = await claimDispatchMailboxAppend(dispatch.id, nowMs);
+  if (!claimedDispatch) {
+    return;
+  }
+  await (options.conversationStore ?? getConversationStore()).recordActivity({
+    activityAtMs: claimedDispatch.createdAtMs,
+    conversationId: getDispatchConversationId(claimedDispatch),
+    destination: claimedDispatch.destination,
+    nowMs,
+    source: "plugin",
+    visibility: claimedDispatch.destinationVisibility
+  });
+  await appendAndEnqueueInboundMessage({
+    message: buildAgentDispatchInboundMessage(claimedDispatch, nowMs),
+    conversationStore: options.conversationStore,
+    nowMs,
+    queue: options.queue,
+    state: options.state
   });
+  await confirmDispatchMailboxAppend(claimedDispatch.id);
 }
-function canClaimDispatch(record, nowMs) {
-  if (isTerminalDispatchStatus(record.status)) {
-    return false;
+function dispatchIdFromMessages(messages) {
+  if (messages.length === 0) {
+    return void 0;
   }
-  if (record.attempt >= record.maxAttempts) {
-    return false;
+  const parsed = messages.map(
+    (message) => agentDispatchMailboxMetadataSchema.safeParse(message.input.metadata)
+  );
+  if (parsed.every((result) => !result.success)) {
+    return void 0;
   }
-  if (record.status === "running" && typeof record.leaseExpiresAtMs === "number" && record.leaseExpiresAtMs > nowMs) {
-    return false;
+  if (parsed.some((result) => !result.success)) {
+    throw new Error("Conversation mailbox mixes dispatch and provider input");
   }
-  return true;
+  const ids = new Set(
+    parsed.map((result) => {
+      if (!result.success) {
+        throw new Error("Dispatch mailbox metadata failed validation");
+      }
+      return result.data.dispatchId;
+    })
+  );
+  if (ids.size !== 1) {
+    throw new Error("Conversation mailbox contains multiple dispatches");
+  }
+  return ids.values().next().value;
 }
-async function runAgentDispatchSlice(callback, deps) {
-  const scheduleCallback = deps.scheduleCallback ?? scheduleDispatchCallback;
-  const scheduleCompletedTasks = deps.scheduleSessionCompletedPluginTasks ?? scheduleSessionCompletedPluginTasks;
-  const turnLifecycle = deps.turnLifecycle ?? new ConversationTurnLifecycleService(getConversationEventStore());
-  const nowMs = Date.now();
-  const claimedDispatch = await withDispatchLock(callback.id, async (state) => {
-    const current = parseDispatchRecord(
-      await state.get(getDispatchStorageKey(callback.id))
+async function resolveAgentDispatchId(context) {
+  const mailboxDispatchId = dispatchIdFromMessages(context.attempt.messages);
+  if (mailboxDispatchId) {
+    return mailboxDispatchId;
+  }
+  if (context.attempt.messages.length > 0) {
+    return void 0;
+  }
+  const summaries = await listAgentTurnSessionSummariesForConversation(
+    context.conversationId
+  );
+  const activeDispatchIds = new Set(
+    summaries.filter(
+      (summary) => (summary.state === "awaiting_resume" || summary.state === "running") && Boolean(summary.dispatchId)
+    ).map((summary) => summary.dispatchId).filter((id) => Boolean(id))
+  );
+  if (activeDispatchIds.size > 1) {
+    throw new Error(
+      `Conversation ${context.conversationId} has multiple active dispatches`
     );
-    if (!current || !canClaimDispatch(current, nowMs) || current.version !== callback.expectedVersion) {
-      return void 0;
+  }
+  const activeDispatchId = activeDispatchIds.values().next().value;
+  if (activeDispatchId) {
+    return activeDispatchId;
+  }
+  const durableDispatchIds = new Set(
+    summaries.map((summary) => summary.dispatchId).filter((id) => Boolean(id))
+  );
+  if (durableDispatchIds.size > 1) {
+    throw new Error(
+      `Conversation ${context.conversationId} has multiple dispatch sessions`
+    );
+  }
+  const durableDispatchId = durableDispatchIds.values().next().value;
+  if (durableDispatchId) {
+    const dispatch2 = await getDispatchRecord(durableDispatchId);
+    if (dispatch2 && !isTerminalDispatchStatus(dispatch2.status)) {
+      return durableDispatchId;
     }
-    return await updateDispatchRecord(state, {
-      ...current,
-      lastCallbackAtMs: nowMs,
-      leaseExpiresAtMs: nowMs + DISPATCH_SLICE_LEASE_MS,
-      status: "running"
-    });
-  });
-  if (!claimedDispatch) {
-    return;
   }
-  let dispatch = claimedDispatch;
+  const prefix = "agent-dispatch:";
+  if (!context.conversationId.startsWith(prefix)) {
+    return void 0;
+  }
+  const dispatchId = context.conversationId.slice(prefix.length);
+  const dispatch = await getDispatchRecord(dispatchId);
+  if (!dispatch) {
+    return void 0;
+  }
+  return isTerminalDispatchStatus(dispatch.status) ? void 0 : dispatch.id;
+}
+function createAgentDispatchWorkRouter(options) {
+  return async (context) => {
+    const dispatchId = await resolveAgentDispatchId(context);
+    return dispatchId ? await options.dispatchWorker(context, dispatchId) : await options.fallbackWorker(context);
+  };
+}
+async function readDispatchTurnResult(dispatch) {
   const conversationId = getDispatchConversationId(dispatch);
   const turnId = getDispatchTurnId(dispatch.id);
-  const logContext = {
-    conversationId,
-    messageConversationId: conversationId,
-    destinationName: dispatch.destination.channelId,
-    runId: dispatch.id,
-    actorType: dispatch.actor.platform,
-    actorId: dispatch.actor.name,
-    assistantUserName: botConfig.userName
+  const storedSession = await getAgentTurnSessionRecord(conversationId, turnId);
+  const summary = (await listAgentTurnSessionSummariesForConversation(conversationId)).find((candidate) => candidate.sessionId === turnId);
+  const session = storedSession ?? summary;
+  const dispatchOutcome = summary?.dispatchOutcome ?? storedSession?.dispatchOutcome;
+  const resultMessageTs = summary?.resultMessageId ?? storedSession?.resultMessageId;
+  const errorMessage = storedSession?.errorMessage;
+  if (dispatchOutcome) {
+    return {
+      ...errorMessage ? { errorMessage } : {},
+      outcome: dispatchOutcome,
+      ...resultMessageTs ? { resultMessageTs } : {}
+    };
+  }
+  if (resultMessageTs) {
+    return {
+      outcome: "completed",
+      resultMessageTs
+    };
+  }
+  if (!session) {
+    return {};
+  }
+  if (session.state === "awaiting_resume") {
+    return { hasResumableRun: true, outcome: "awaiting_resume" };
+  }
+  if (session.state === "running") {
+    return { hasResumableRun: true };
+  }
+  if (session.state !== "completed") {
+    return {};
+  }
+  return {
+    outcome: "completed",
+    ...resultMessageTs ? { resultMessageTs } : {}
   };
-  const destinationLockId = getDispatchDestinationLockId(dispatch.destination);
-  const stateAdapter = getStateAdapter();
-  let lifecycleStarted = false;
-  let lifecycleTerminalized = false;
-  let failureCode = "persistence_failed";
-  await stateAdapter.connect();
-  const destinationLock = await stateAdapter.acquireLock(
-    destinationLockId,
-    DISPATCH_SLICE_LEASE_MS
-  );
-  if (!destinationLock) {
-    await markDispatch({
-      dispatch,
-      status: "pending",
-      errorMessage: "Destination conversation is busy"
-    });
-    return;
+}
+async function projectDispatchTurnResult(dispatchId, result) {
+  switch (result.outcome) {
+    case "awaiting_resume":
+      await markDispatchAwaitingResume(dispatchId);
+      break;
+    case "blocked":
+      await markDispatchBlocked(
+        dispatchId,
+        "Dispatch requires authorization that is unavailable for background work",
+        result.resultMessageTs
+      );
+      break;
+    case "failed":
+      await markDispatchFailed(
+        dispatchId,
+        result.errorMessage ?? "Agent turn failed",
+        result.resultMessageTs
+      );
+      break;
+    case "completed":
+      await markDispatchCompleted(dispatchId, result.resultMessageTs);
+      break;
   }
-  try {
-    const startedDispatch = await withDispatchLock(
-      dispatch.id,
-      async (state) => {
-        const current = parseDispatchRecord(
-          await state.get(getDispatchStorageKey(dispatch.id))
-        );
-        if (!current || current.status !== "running" || current.version !== dispatch.version || current.attempt >= current.maxAttempts) {
-          return void 0;
-        }
-        return await updateDispatchRecord(state, {
-          ...current,
-          attempt: current.attempt + 1
-        });
-      }
-    );
-    if (!startedDispatch) {
-      return;
+}
+function getDispatchBlockingError(error) {
+  const cause = getConversationTurnBoundaryError(error)?.cause ?? error;
+  return cause instanceof AuthorizationFlowDisabledError || cause instanceof PluginCredentialFailureError ? cause : void 0;
+}
+async function persistBlockedDispatchTurn(dispatch, error) {
+  const conversationId = getDispatchConversationId(dispatch);
+  const sessionId = getDispatchTurnId(dispatch.id);
+  const session = await getAgentTurnSessionRecord(conversationId, sessionId);
+  await recordAgentTurnSessionSummary({
+    actor: dispatch.actor,
+    conversationId,
+    destination: dispatch.destination,
+    destinationVisibility: dispatch.destinationVisibility,
+    dispatchId: dispatch.id,
+    dispatchOutcome: "blocked",
+    sessionId,
+    sliceId: session?.sliceId ?? 1,
+    source: dispatch.source,
+    state: "failed",
+    surface: "api"
+  });
+  await markDispatchBlocked(
+    dispatch.id,
+    error instanceof AuthorizationFlowDisabledError ? `Dispatch requires ${error.provider} authorization.` : error.message
+  );
+}
+function createAgentDispatchConversationWorker(options) {
+  return async (context, dispatchId) => {
+    const dispatch = await getDispatchRecord(dispatchId);
+    if (!dispatch) {
+      throw new Error(`Dispatch record is missing for ${dispatchId}`);
     }
-    dispatch = startedDispatch;
-    const persisted = await getPersistedThreadState(conversationId);
-    const conversation = coerceThreadConversationState(persisted);
-    await hydrateConversationMessages({ conversation, conversationId });
-    const completedSession = await getAgentTurnSessionRecord(
-      conversationId,
-      turnId
-    );
-    if (completedSession?.state === "completed") {
-      const deliveredMessage = [...conversation.messages].reverse().find(
-        (message) => message.id.startsWith(`${turnId}:assistant:`) && typeof message.meta?.slackTs === "string"
+    const expectedConversationId = getDispatchConversationId(dispatch);
+    if (context.conversationId !== expectedConversationId) {
+      throw new Error(
+        `Dispatch ${dispatch.id} belongs to ${expectedConversationId}, not ${context.conversationId}`
       );
-      await markDispatch({
-        dispatch,
-        status: "completed",
-        ...deliveredMessage?.meta?.slackTs ? { resultMessageTs: deliveredMessage.meta.slackTs } : {}
-      });
-      return;
     }
-    let artifacts = coerceThreadArtifactsState(persisted);
-    let sandboxRef = getPersistedSandboxState(persisted);
-    const channelConfiguration = getChannelConfigurationServiceById(
-      dispatch.destination.channelId
-    );
-    const configuration = await channelConfiguration.resolveValues();
-    const userMessageId = upsertDispatchUserMessage({
-      conversation,
-      dispatch,
-      nowMs
-    });
-    await persistConversationMessages({ conversation, conversationId });
-    await turnLifecycle.start({
-      conversationId,
-      turnId,
-      createdAtMs: nowMs,
-      inputMessageIds: [userMessageId],
-      surface: "api"
-    });
-    lifecycleStarted = true;
-    failureCode = "agent_run_failed";
-    const conversationContext = buildConversationContext(conversation, {
-      excludeMessageId: userMessageId
-    });
-    let resultMessageTs;
-    let assistantMessageDelivered = turnHasReply(conversation, turnId);
-    const deliverAssistantMessage = async (assistantMessage) => {
-      if (!assistantMessage.text.trim()) {
+    if (context.destination.platform !== dispatch.destination.platform || context.destination.teamId !== dispatch.destination.teamId || context.destination.channelId !== dispatch.destination.channelId) {
+      throw new Error(
+        `Dispatch ${dispatch.id} destination does not match its conversation lease`
+      );
+    }
+    let acknowledged = context.attempt.messages.length === 0;
+    const acknowledge = async () => {
+      if (acknowledged) {
         return;
       }
-      failureCode = "delivery_failed";
       try {
-        resultMessageTs = await sendSlackReply({
-          channelId: dispatch.destination.channelId,
-          conversationId,
-          text: assistantMessage.text
-        });
-      } catch (error) {
-        if (isRetryableSlackPostError(error)) {
-          throw new RetryableDeliveryError(error);
-        }
-        throw error;
-      }
-      assistantMessageDelivered = true;
-      const recordedMessageId = recordDeliveredAssistantMessage({
-        conversation,
-        sessionId: turnId,
-        text: assistantMessage.text,
-        userMessageId
-      });
-      if (resultMessageTs) {
-        markConversationMessage(conversation, recordedMessageId, {
-          slackTs: resultMessageTs
-        });
-      }
-      try {
-        await persistWithRetry(
-          () => persistConversationMessages({ conversation, conversationId })
-        );
-      } catch (persistError) {
-        logException(
-          new Error("Accepted assistant message persistence failed"),
-          "agent_dispatch_assistant_message_post_delivery_persist_failed",
-          logContext,
-          {
-            "error.type": persistError instanceof Error ? persistError.name : typeof persistError
-          },
-          "Failed to persist an accepted dispatch assistant message"
+        await context.attempt.ack();
+      } catch {
+        throw new TurnInputCommitLostError(
+          `Conversation work lease lost before dispatch inbox ack for ${context.conversationId}`
         );
       }
-      failureCode = "agent_run_failed";
+      acknowledged = true;
     };
-    const outcome = await deps.agentRunner.run({
-      conversationId,
-      turnId,
-      runId: dispatch.id,
-      input: {
-        messageText: dispatch.input,
-        conversationContext,
-        // Pi history for redelivered dispatch slices comes from the SQL
-        // event-store projection, not a thread-state mirror.
-        piMessages: await loadProjection({ conversationId })
-      },
-      routing: {
-        credentialContext: {
-          actor: dispatch.actor,
-          ...dispatch.credentialSubject ? { subject: dispatch.credentialSubject } : {}
-        },
-        destination: dispatch.destination,
-        destinationVisibility: dispatch.destinationVisibility,
-        source: dispatch.source,
-        dispatch: {
-          actor: dispatch.actor,
-          metadata: dispatch.metadata,
-          plugin: dispatch.plugin
-        },
-        surface: "api",
-        toolChannelId: dispatch.destination.channelId
-      },
-      policy: {
-        authorizationFlowMode: "disabled",
-        configuration,
-        channelConfiguration
-      },
-      state: {
-        artifactState: artifacts,
-        sandboxRef
-      },
-      delivery: {
-        onAssistantMessage: deliverAssistantMessage
-      },
-      durability: {
-        onSandboxRefChanged: async (nextSandboxRef) => {
-          sandboxRef = nextSandboxRef;
-          await persistRuntimePatch({
-            threadId: conversationId,
-            conversation,
-            artifacts,
-            sandboxRef
-          });
-        },
-        onArtifactStateUpdated: async (nextArtifacts2) => {
-          artifacts = nextArtifacts2;
-          await persistRuntimePatch({
-            threadId: conversationId,
-            conversation,
-            artifacts,
-            sandboxRef
-          });
-        }
-      }
-    });
-    if (outcome.status === "awaiting_auth") {
-      await turnLifecycle.fail({
-        conversationId,
-        turnId,
-        createdAtMs: Date.now(),
-        failureCode: "agent_run_failed"
-      });
-      lifecycleTerminalized = true;
-      await markDispatch({
-        dispatch,
-        status: "blocked",
-        errorMessage: "Dispatch requires authorization from an interactive user turn."
-      });
-      return;
+    if (isTerminalDispatchStatus(dispatch.status)) {
+      await acknowledge();
+      return { status: "completed" };
     }
-    if (outcome.status === "suspended") {
-      const awaiting = await markDispatch({
-        dispatch,
-        status: "awaiting_resume"
-      });
-      await scheduleCallback({
-        id: awaiting.id,
-        expectedVersion: awaiting.version
-      });
-      return;
+    const durableResult = await readDispatchTurnResult(dispatch);
+    if (durableResult.outcome === "blocked" || durableResult.outcome === "completed" || durableResult.outcome === "failed") {
+      await projectDispatchTurnResult(dispatch.id, durableResult);
+      await acknowledge();
+      return { status: "completed" };
     }
-    let reply = outcome.result;
-    const failure = reply.diagnostics.outcome === "success" ? void 0 : reply.diagnostics.errorMessage ?? `Agent turn ended with ${reply.diagnostics.outcome}.`;
-    let modelFailureEventId;
-    if (failure) {
-      const finalized = finalizeFailedTurnReplyWithEvent({
-        reply,
-        logException,
-        context: {
-          ...logContext,
-          modelId: reply.diagnostics.modelId
-        }
-      });
-      reply = finalized.reply;
-      modelFailureEventId = finalized.eventId;
-      await deliverAssistantMessage({ text: reply.text });
-    }
-    failureCode = "persistence_failed";
-    markConversationMessage(conversation, userMessageId, {
-      replied: true,
-      skippedReason: void 0
-    });
-    updateConversationStats(conversation);
-    const nextArtifacts = reply.artifactStatePatch ? mergeArtifactsState(artifacts, reply.artifactStatePatch) : artifacts;
-    let statePersisted = false;
-    try {
-      await persistWithRetry(async () => {
-        await persistConversationMessages({ conversation, conversationId });
-        await persistRuntimePatch({
-          threadId: conversationId,
-          conversation,
-          artifacts: nextArtifacts,
-          sandboxRef: reply.sandboxRef ?? sandboxRef
-        });
-      });
-      statePersisted = true;
-    } catch (persistError) {
-      const eventId = logException(
-        persistError,
-        "agent_dispatch_post_delivery_persist_failed",
-        logContext,
-        {},
-        "Failed to persist delivered dispatch state after Slack accepted the reply"
+    if (Date.now() - dispatch.createdAtMs > AGENT_DISPATCH_MAX_AGE_MS) {
+      await markDispatchFailed(
+        dispatch.id,
+        "Dispatch exceeded its maximum processing age"
       );
-      await turnLifecycle.fail({
-        conversationId,
-        turnId,
-        createdAtMs: Date.now(),
-        failureCode: "persistence_failed",
-        ...eventId ? { eventId } : {}
-      });
-      lifecycleTerminalized = true;
+      await acknowledge();
+      return { status: "completed" };
     }
-    if (reply.piMessages?.length) {
-      await completeDeliveredTurn({
-        conversationId,
-        sessionId: turnId,
-        sliceId: 1,
-        messages: reply.piMessages,
-        modelId: reply.diagnostics.modelId,
-        durationMs: reply.diagnostics.durationMs,
-        usage: reply.diagnostics.usage,
-        reasoningLevel: reply.diagnostics.reasoningLevel,
-        destination: dispatch.destination,
-        destinationVisibility: dispatch.destinationVisibility,
-        source: dispatch.source,
-        actor: dispatch.actor,
-        surface: "api"
-      });
+    const runningDispatch = await markDispatchRunning(dispatch.id);
+    if (!runningDispatch) {
+      throw new Error(`Dispatch record disappeared for ${dispatch.id}`);
     }
-    if (statePersisted) {
-      if (failure) {
-        await turnLifecycle.fail({
-          conversationId,
-          turnId,
-          createdAtMs: Date.now(),
-          failureCode: "model_execution_failed",
-          ...modelFailureEventId ? { eventId: modelFailureEventId } : {}
+    if (isTerminalDispatchStatus(runningDispatch.status)) {
+      await acknowledge();
+      return { status: "completed" };
+    }
+    try {
+      const resumesDurableTurn = durableResult.hasResumableRun === true;
+      if (resumesDurableTurn && context.attempt.messages.length > 0) {
+        await acknowledge();
+      }
+      let result;
+      if (resumesDurableTurn) {
+        await options.resumeTurn(dispatch, {
+          shouldYield: context.shouldYield
         });
+        result = await readDispatchTurnResult(dispatch);
       } else {
-        await turnLifecycle.complete({
-          conversationId,
-          turnId,
-          createdAtMs: Date.now(),
-          outcome: assistantMessageDelivered ? "success" : "no_reply"
+        const runtimeResult = await options.runTurn(dispatch, {
+          ack: acknowledge,
+          shouldYield: context.shouldYield
         });
+        result = runtimeResult.outcome ? runtimeResult : {
+          ...runtimeResult,
+          ...await readDispatchTurnResult(dispatch)
+        };
       }
-      lifecycleTerminalized = true;
-    }
-    dispatch = await markDispatch({
-      dispatch,
-      status: failure ? "failed" : "completed",
-      ...failure ? { errorMessage: failure } : {},
-      resultMessageTs
-    });
-    if (!failure) {
-      try {
-        await scheduleCompletedTasks({
-          conversationId,
-          sessionId: turnId
-        });
-      } catch (error) {
-        logException(
-          error,
-          "plugin_session_completed_task_schedule_failed",
-          logContext,
-          {},
-          "Plugin session.completed task scheduling failed"
+      if (!result.outcome) {
+        throw new Error(
+          `Dispatch turn ${dispatch.id} returned without a durable outcome`
         );
       }
-    }
-  } catch (error) {
-    if (error instanceof AuthorizationFlowDisabledError) {
-      if (lifecycleStarted && !lifecycleTerminalized) {
-        await turnLifecycle.fail({
-          conversationId,
-          turnId,
-          createdAtMs: Date.now(),
-          failureCode: "agent_run_failed"
-        });
-        lifecycleTerminalized = true;
+      await projectDispatchTurnResult(dispatch.id, result);
+      if (result.outcome && !acknowledged) {
+        await acknowledge();
       }
-      await markDispatch({
-        dispatch,
-        status: "blocked",
-        errorMessage: `Dispatch requires ${error.provider} authorization.`
-      });
-      return;
-    }
-    if (error instanceof PluginCredentialFailureError) {
-      if (lifecycleStarted && !lifecycleTerminalized) {
-        await turnLifecycle.fail({
-          conversationId,
-          turnId,
-          createdAtMs: Date.now(),
-          failureCode: "agent_run_failed"
-        });
-        lifecycleTerminalized = true;
+      return result.outcome === "awaiting_resume" && context.shouldYield() ? { status: "yielded" } : { status: "completed" };
+    } catch (error) {
+      if (isCooperativeTurnYieldError(error)) {
+        await markDispatchAwaitingResume(dispatch.id);
+        return { status: "yielded" };
       }
-      await markDispatch({
-        dispatch,
-        status: "blocked",
-        errorMessage: error.message
-      });
-      return;
-    }
-    const eventId = logException(
-      error,
-      "agent_dispatch_run_failed",
-      {
-        ...logContext,
-        modelId: standardModelId(botConfig)
-      },
-      {},
-      "Agent dispatch failed"
-    );
-    if (lifecycleStarted && !lifecycleTerminalized) {
-      await turnLifecycle.fail({
-        conversationId,
-        turnId,
-        createdAtMs: Date.now(),
-        failureCode,
-        ...eventId ? { eventId } : {}
-      });
-      lifecycleTerminalized = true;
+      if (isTurnInputCommitLostError(error)) {
+        return { status: "lost_lease" };
+      }
+      const blockingError = getDispatchBlockingError(error);
+      if (blockingError) {
+        await persistBlockedDispatchTurn(dispatch, blockingError);
+        await acknowledge();
+        return { status: "completed" };
+      }
+      if (!context.attempt.isFinalAttempt) {
+        throw error;
+      }
+      await markDispatchFailed(
+        dispatch.id,
+        error instanceof Error ? error.message : "Dispatch turn failed"
+      );
+      await acknowledge();
+      return { status: "completed" };
     }
-    await markDispatch({
-      dispatch,
-      status: "failed",
-      errorMessage: error instanceof Error ? error.message : String(error)
-    });
-  } finally {
-    await stateAdapter.releaseLock(destinationLock);
-  }
+  };
 }
 
 // src/handlers/agent-dispatch.ts
@@ -1179,15 +1100,24 @@ async function POST(request, waitUntil, options) {
     return new Response("Unauthorized", { status: 401 });
   }
   waitUntil(
-    () => runAgentDispatchSlice(payload, {
-      agentRunner: options.agentRunner
-    }).catch((error) => {
+    (async () => {
+      const dispatch = await getDispatchRecord(payload.id);
+      if (!dispatch) {
+        throw new Error(`Dispatch record is missing for ${payload.id}`);
+      }
+      if (isTerminalDispatchStatus(dispatch.status)) {
+        return;
+      }
+      await enqueueAgentDispatch(dispatch, {
+        queue: options.conversationWorkQueue
+      });
+    })().catch((error) => {
       logException(
         error,
-        "agent_dispatch_handler_failed",
+        "agent_dispatch_callback_failed",
         {},
         { "app.dispatch.id": payload.id },
-        "Agent dispatch handler failed"
+        "Legacy dispatch callback failed"
       );
     })
   );
@@ -1446,12 +1376,6 @@ async function verifyDispatchCredentialSubjectAccess(options, plugin) {
 
 // src/chat/agent-dispatch/context.ts
 var MAX_DISPATCHES_PER_HEARTBEAT = 25;
-function shouldScheduleDispatch(record, nowMs) {
-  if (isTerminalDispatchStatus(record.status)) {
-    return false;
-  }
-  return record.status !== "running" || typeof record.leaseExpiresAtMs !== "number" || record.leaseExpiresAtMs <= nowMs;
-}
 function bindDispatchCredentialSubject(options, plugin) {
   const { credentialSubject, ...baseOptions } = options;
   if (!credentialSubject) {
@@ -1505,10 +1429,10 @@ function createHeartbeatContext(args) {
           nowMs: args.nowMs
         });
         dispatchCount += 1;
-        if (shouldScheduleDispatch(result.record, args.nowMs)) {
-          await scheduleDispatchCallback({
-            id: result.record.id,
-            expectedVersion: result.record.version
+        if (!isTerminalDispatchStatus(result.record.status)) {
+          await enqueueAgentDispatch(result.record, {
+            queue: args.conversationWorkQueue,
+            nowMs: args.nowMs
           });
         }
         return {
@@ -1527,37 +1451,9 @@ function createHeartbeatContext(args) {
 }
 
 // src/chat/agent-dispatch/heartbeat.ts
-var DEFAULT_RECOVERY_LIMIT2 = 25;
 var DEFAULT_PLUGIN_LIMIT = 25;
-var DISPATCH_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var PLUGIN_HEARTBEAT_TIMEOUT_MS = 25e3;
-function isStaleDispatch(args) {
-  if (args.record.status === "running") {
-    return typeof args.record.leaseExpiresAtMs === "number" && args.record.leaseExpiresAtMs <= args.nowMs;
-  }
-  if (args.record.status === "awaiting_resume") {
-    return typeof args.record.leaseExpiresAtMs !== "number" || args.record.leaseExpiresAtMs <= args.nowMs;
-  }
-  if (args.record.status === "pending") {
-    return typeof args.record.lastCallbackAtMs !== "number" || args.record.lastCallbackAtMs + 6e4 <= args.nowMs;
-  }
-  return false;
-}
-async function failDispatch(args) {
-  await withDispatchLock(args.record.id, async (state) => {
-    const current = parseDispatchRecord(
-      await state.get(getDispatchStorageKey(args.record.id))
-    ) ?? args.record;
-    if (isTerminalDispatchStatus(current.status)) {
-      return;
-    }
-    await updateDispatchRecord(state, {
-      ...current,
-      errorMessage: args.errorMessage,
-      status: "failed"
-    });
-  });
-}
+var DISPATCH_MAILBOX_APPEND_LIMIT = 100;
 async function runWithTimeout(promise, timeoutMs) {
   let timeout;
   try {
@@ -1575,52 +1471,6 @@ async function runWithTimeout(promise, timeoutMs) {
     }
   }
 }
-async function recoverStaleDispatches(args) {
-  const ids = await listIncompleteDispatchIds();
-  let recovered = 0;
-  for (const id of ids) {
-    if (recovered >= (args.limit ?? DEFAULT_RECOVERY_LIMIT2)) {
-      break;
-    }
-    const record = await getDispatchRecord(id);
-    if (!record || isTerminalDispatchStatus(record.status)) {
-      continue;
-    }
-    try {
-      if (!isStaleDispatch({ record, nowMs: args.nowMs })) {
-        continue;
-      }
-      if (record.createdAtMs + DISPATCH_MAX_AGE_MS <= args.nowMs) {
-        await failDispatch({
-          record,
-          errorMessage: "Dispatch expired before completion."
-        });
-        continue;
-      }
-      if (record.attempt >= record.maxAttempts) {
-        await failDispatch({
-          record,
-          errorMessage: "Dispatch exceeded retry attempts."
-        });
-        continue;
-      }
-      await scheduleDispatchCallback({
-        id: record.id,
-        expectedVersion: record.version
-      });
-      recovered += 1;
-    } catch (error) {
-      logException(
-        error,
-        "agent_dispatch_recovery_failed",
-        { runId: record.id },
-        { "app.plugin.name": record.plugin },
-        "Agent dispatch recovery failed"
-      );
-    }
-  }
-  return recovered;
-}
 async function runPluginHeartbeats(args) {
   let count = 0;
   for (const plugin of getPlugins()) {
@@ -1638,6 +1488,7 @@ async function runPluginHeartbeats(args) {
         Promise.resolve(
           heartbeat(
             createHeartbeatContext({
+              conversationWorkQueue: args.conversationWorkQueue,
               plugin,
               nowMs: args.nowMs
             })
@@ -1667,13 +1518,55 @@ async function runPluginHeartbeats(args) {
     }
   }
 }
+async function recoverPendingDispatchMailboxAppends(args) {
+  const ids = (await listPendingDispatchMailboxAppends()).slice(
+    0,
+    DISPATCH_MAILBOX_APPEND_LIMIT
+  );
+  for (const id of ids) {
+    try {
+      const dispatch = await getDispatchRecord(id);
+      if (!dispatch || isTerminalDispatchStatus(dispatch.status)) {
+        await confirmDispatchMailboxAppend(id);
+        continue;
+      }
+      if (args.nowMs - dispatch.createdAtMs > AGENT_DISPATCH_MAX_AGE_MS) {
+        await markDispatchFailed(
+          id,
+          "Dispatch expired before its conversation mailbox append completed"
+        );
+        await confirmDispatchMailboxAppend(id);
+        continue;
+      }
+      await enqueueAgentDispatch(dispatch, {
+        nowMs: args.nowMs,
+        queue: args.conversationWorkQueue
+      });
+    } catch (error) {
+      logException(
+        error,
+        "dispatch_mailbox_append_recovery_failed",
+        {},
+        { "app.dispatch.id": id },
+        "Pending dispatch mailbox append recovery failed"
+      );
+    }
+  }
+}
 async function runHeartbeat(args) {
+  const queue = args.conversationWorkQueue ?? getVercelConversationWorkQueue();
   await recoverConversationWork({
     nowMs: args.nowMs,
-    queue: args.conversationWorkQueue ?? getVercelConversationWorkQueue()
+    queue
+  });
+  await recoverPendingDispatchMailboxAppends({
+    conversationWorkQueue: queue,
+    nowMs: args.nowMs
+  });
+  await runPluginHeartbeats({
+    conversationWorkQueue: queue,
+    nowMs: args.nowMs
   });
-  await recoverStaleDispatches({ nowMs: args.nowMs });
-  await runPluginHeartbeats({ nowMs: args.nowMs });
 }
 
 // src/handlers/heartbeat.ts
@@ -2412,7 +2305,7 @@ import {
   Message,
   ThreadImpl
 } from "chat";
-import { z as z3 } from "zod";
+import { z as z5 } from "zod";
 
 // src/chat/ingress/message-router.ts
 function normalizeIncomingSlackThreadId(threadId, message) {
@@ -2583,14 +2476,14 @@ async function ensureSlackMessageActorIdentity(message, teamId, lookupSlackUser2
 }
 
 // src/chat/slack/user.ts
-import { z as z2 } from "zod";
-var slackUserInfoSchema = z2.object({
-  ok: z2.literal(true),
-  user: z2.object({
-    name: z2.string().nullish(),
-    profile: z2.object({
-      email: z2.string().nullish(),
-      real_name: z2.string().nullish()
+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()
     }).optional()
   })
 });
@@ -2683,17 +2576,17 @@ function stripLeadingSteeringOverride(text) {
 }
 
 // src/chat/task-execution/slack-work.ts
-var slackConversationRouteSchema = z3.enum(["mention", "subscribed"]);
+var slackConversationRouteSchema = z5.enum(["mention", "subscribed"]);
 function hasSteeringOverride(text) {
   return stripLeadingSteeringOverride(text) !== text;
 }
-var serializedDateSchema = z3.iso.datetime();
-var mdastPointSchema = z3.object({
-  column: z3.number().int().positive(),
-  line: z3.number().int().positive(),
-  offset: z3.number().int().nonnegative().optional()
+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()
 }).strict();
-var mdastPositionSchema = z3.object({
+var mdastPositionSchema = z5.object({
   end: mdastPointSchema,
   start: mdastPointSchema
 }).strict();
@@ -2805,7 +2698,7 @@ function isFormattedContentNode(value) {
       return false;
   }
 }
-var formattedContentSchema = z3.custom(
+var formattedContentSchema = z5.custom(
   (value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
       return false;
@@ -2815,79 +2708,79 @@ var formattedContentSchema = z3.custom(
   },
   "must be a valid formatted-content root"
 );
-var serializedMessageSchema = z3.object({
-  _type: z3.literal("chat:Message"),
-  attachments: z3.array(
-    z3.object({
-      type: z3.enum(["image", "file", "video", "audio"]),
-      url: z3.string().optional(),
-      name: z3.string().optional(),
-      mimeType: z3.string().optional(),
-      size: z3.number().finite().optional(),
-      width: z3.number().finite().optional(),
-      height: z3.number().finite().optional(),
-      fetchMetadata: z3.record(z3.string(), z3.string()).optional()
+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()
     }).strict()
   ),
-  author: z3.object({
-    userId: z3.string(),
-    userName: z3.string(),
-    fullName: z3.string(),
-    isBot: z3.union([z3.boolean(), z3.literal("unknown")]),
-    isMe: z3.boolean()
+  author: z5.object({
+    userId: z5.string(),
+    userName: z5.string(),
+    fullName: z5.string(),
+    isBot: z5.union([z5.boolean(), z5.literal("unknown")]),
+    isMe: z5.boolean()
   }).strict(),
   formatted: formattedContentSchema,
-  id: z3.string().min(1),
-  isMention: z3.boolean().optional(),
-  links: z3.array(
-    z3.object({
-      url: z3.string(),
-      title: z3.string().optional(),
-      description: z3.string().optional(),
-      imageUrl: z3.string().optional(),
-      siteName: z3.string().optional()
+  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()
     }).strict()
   ).optional(),
-  metadata: z3.object({
+  metadata: z5.object({
     dateSent: serializedDateSchema,
-    edited: z3.boolean(),
+    edited: z5.boolean(),
     editedAt: serializedDateSchema.optional()
   }).strict(),
-  raw: z3.unknown(),
-  text: z3.string(),
-  threadId: z3.string().min(1)
+  raw: z5.unknown(),
+  text: z5.string(),
+  threadId: z5.string().min(1)
 }).strict();
-var serializedThreadSchema = z3.object({
-  _type: z3.literal("chat:Thread"),
-  adapterName: z3.literal("slack"),
-  channelId: z3.string().min(1),
-  channelVisibility: z3.enum(["private", "workspace", "external", "unknown"]).optional(),
+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(),
   currentMessage: serializedMessageSchema.optional(),
-  id: z3.string().min(1),
-  isDM: z3.boolean()
+  id: z5.string().min(1),
+  isDM: z5.boolean()
 }).strict();
-var slackInstallationSchema = z3.object({
-  enterpriseId: z3.string().optional(),
-  isEnterpriseInstall: z3.boolean().optional(),
-  teamId: z3.string().optional()
+var slackInstallationSchema = z5.object({
+  enterpriseId: z5.string().optional(),
+  isEnterpriseInstall: z5.boolean().optional(),
+  teamId: z5.string().optional()
 }).strict();
-var slackConversationMessageMetadataBaseSchema = z3.object({
+var slackConversationMessageMetadataBaseSchema = z5.object({
   installation: slackInstallationSchema.optional(),
   message: serializedMessageSchema,
-  platform: z3.literal("slack"),
+  platform: z5.literal("slack"),
   route: slackConversationRouteSchema,
   thread: serializedThreadSchema
 });
-var slackConversationMessageMetadataSchema = z3.union([
+var slackConversationMessageMetadataSchema = z5.union([
   slackConversationMessageMetadataBaseSchema.strict(),
   slackConversationMessageMetadataBaseSchema.extend({
-    kind: z3.literal("resource_event"),
-    resourceEvent: z3.object({
-      eventKey: z3.string(),
-      eventType: z3.string(),
-      provider: z3.string(),
-      resourceRef: z3.string(),
-      subscriptionId: z3.string()
+    kind: z5.literal("resource_event"),
+    resourceEvent: z5.object({
+      eventKey: z5.string(),
+      eventType: z5.string(),
+      provider: z5.string(),
+      resourceRef: z5.string(),
+      subscriptionId: z5.string()
     }).strict()
   }).strict()
 ]);
@@ -4799,14 +4692,14 @@ function registerVercelPluginTaskDevConsumer() {
 }
 
 // src/chat/services/subscribed-decision.ts
-import { z as z4 } from "zod";
-var replyDecisionSchema = z4.object({
-  should_reply: z4.boolean().describe("Whether Junior should respond to this thread message."),
-  should_unsubscribe: z4.boolean().describe(
+import { z as z6 } from "zod";
+var replyDecisionSchema = z6.object({
+  should_reply: z6.boolean().describe("Whether Junior should respond to this thread message."),
+  should_unsubscribe: z6.boolean().describe(
     "Whether Junior should unsubscribe from this thread because the user clearly asked it to stop participating."
   ),
-  confidence: z4.number().min(0).max(1).describe("Classifier confidence from 0 to 1."),
-  reason: z4.string().describe("Short reason for the decision; use an empty string if none.")
+  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.")
 }).strict();
 var ROUTER_CONFIDENCE_THRESHOLD = 0.8;
 var ROUTER_CLASSIFIER_MAX_TOKENS = 240;
@@ -6580,11 +6473,11 @@ function getSlackMessageTs(message) {
 }
 
 // src/chat/slack/action-token.ts
-import { z as z5 } from "zod";
-var slackActionTokenSchema = z5.string().trim().min(1).brand();
-var slackMessageEnvelopeSchema = z5.object({
-  raw: z5.object({
-    action_token: z5.unknown().optional()
+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()
   }).optional()
 });
 function readSlackActionToken(message) {
@@ -6869,14 +6762,14 @@ function createReplyToThread(deps) {
     }
     const threadId = getThreadId(thread, message);
     const channelId = getChannelId(thread, message);
-    const channelName = channelId ? await resolveChannelName(thread) : void 0;
+    const channelName = !options.execution && channelId ? await resolveChannelName(thread) : void 0;
     const slackChannelType = resolveSlackChannelTypeFromMessage(message);
     const slackConversation = resolveSlackConversationContext({
       channelId,
       channelName,
       channelType: slackChannelType
     });
-    const destinationVisibility = conversationVisibilityFromSlackChannelType(slackChannelType);
+    const destinationVisibility = options.execution?.destinationVisibility ?? conversationVisibilityFromSlackChannelType(slackChannelType);
     const threadTs = getThreadTs(threadId);
     const assistantThreadContext = getAssistantThreadContext(message);
     const messageTs = getMessageTs(message);
@@ -6885,7 +6778,7 @@ function createReplyToThread(deps) {
       "Slack reply execution"
     );
     const teamId = destination.teamId;
-    const source = createSlackSource({
+    const source = options.execution?.source ?? createSlackSource({
       channelId: channelId ?? destination.channelId,
       messageTs,
       teamId,
@@ -6893,7 +6786,7 @@ function createReplyToThread(deps) {
       type: destinationVisibility === "public" ? "pub" : "priv"
     });
     const slackActionToken = readSlackActionToken(message);
-    const runId = getRunId(thread, message);
+    const runId = options.execution?.dispatch?.id ?? getRunId(thread, message);
     const conversationId = threadId ?? runId;
     if (!conversationId) {
       throw new Error("Slack reply execution requires a conversation id");
@@ -6935,7 +6828,7 @@ function createReplyToThread(deps) {
           )
         );
         const effectiveUserText = currentText.userText;
-        const credentialContext = resourceEventCredentialContext(message) ?? {
+        const credentialContext = options.execution?.credentialContext ?? resourceEventCredentialContext(message) ?? {
           actor: { type: "user", userId: message.author.userId }
         };
         const actor = "type" in credentialContext.actor ? await ensureSlackMessageActorIdentity(
@@ -6953,15 +6846,17 @@ function createReplyToThread(deps) {
             options.explicitMention || message.isMention
           ),
           queuedMessages: options.queuedMessages,
+          channelConfiguration: options.execution?.channelConfiguration,
           context: {
             threadId,
             actorId: slackActorId,
             channelId,
             runId
-          }
+          },
+          skipBackfill: options.skipBackfill
         });
         const slackMessageTs = getSlackMessageTs(message);
-        const turnId = buildDeterministicTurnId(message.id);
+        const turnId = options.execution?.turnId ?? buildDeterministicTurnId(message.id);
         const turnTraceContext = {
           conversationId,
           messageConversationId: threadId,
@@ -7109,6 +7004,11 @@ function createReplyToThread(deps) {
           return drainParkedInputToEventLog(parkedPairs);
         };
         if (preparedState.userMessageAlreadyReplied) {
+          const deliveredMessage = [...preparedState.conversation.messages].reverse().find(
+            (candidate) => candidate.role === "assistant" && candidate.id.startsWith(`${turnId}:assistant:`) && candidate.meta?.replied === true
+          );
+          options.onTurnDeliveryAccepted?.(deliveredMessage?.meta?.slackTs);
+          options.onTurnOutcome?.({ outcome: "completed" });
           await persistThreadState(thread, {
             conversation: preparedState.conversation
           });
@@ -7185,7 +7085,7 @@ function createReplyToThread(deps) {
             }
           }
         }
-        const configReply = await maybeApplyProviderDefaultConfigRequest({
+        const configReply = options.execution?.skipProviderDefaultConfig ? void 0 : await maybeApplyProviderDefaultConfigRequest({
           channelConfiguration: preparedState.channelConfiguration,
           actorId: actor?.userId,
           text: effectiveUserText
@@ -7238,7 +7138,7 @@ function createReplyToThread(deps) {
                 preparedState.userMessageId
               ])
             ],
-            surface: "slack",
+            surface: options.execution?.surface ?? "slack",
             turnId
           });
         }
@@ -7251,7 +7151,8 @@ function createReplyToThread(deps) {
             sliceId: 1,
             startedAtMs: turnStartedAtMs,
             state: "running",
-            surface: "slack",
+            surface: options.execution?.surface ?? "slack",
+            dispatchId: options.execution?.dispatch?.id,
             actor: executionActor,
             destination,
             destinationVisibility,
@@ -7323,13 +7224,36 @@ function createReplyToThread(deps) {
         let shouldPersistFailureState = true;
         let runResultHandled = false;
         let assistantMessageDelivered = false;
+        let acceptedDeliveryId;
         let lifecycleTerminalized = false;
         let turnCompletionNotified = false;
+        const recordDispatchOutcome = async (dispatchOutcome, state) => {
+          const dispatchId = options.execution?.dispatch?.id;
+          if (!dispatchId) {
+            return;
+          }
+          await recordAgentTurnSessionSummary({
+            channelName,
+            conversationId,
+            destination,
+            destinationVisibility,
+            dispatchId,
+            dispatchOutcome,
+            ...acceptedDeliveryId ? { resultMessageId: acceptedDeliveryId } : {},
+            sessionId: turnId,
+            sliceId: 1,
+            source,
+            startedAtMs: message.metadata.dateSent.getTime(),
+            state,
+            surface: options.execution?.surface ?? "slack"
+          });
+        };
         let latestArtifacts = preparedState.artifacts;
         let assistantTitleArtifacts = {};
         let agentContinueScheduleError;
         let boundaryFailureCode = "agent_run_failed";
         let finalizedFailureEventId;
+        let terminalDispatchFailureOutcome;
         const notifyTurnCompleted = async () => {
           if (turnCompletionNotified) {
             return;
@@ -7337,7 +7261,7 @@ function createReplyToThread(deps) {
           await options.onTurnCompleted?.();
           turnCompletionNotified = true;
         };
-        const deliverAssistantMessage = async (assistantMessage) => {
+        const deliverAssistantMessage = async (assistantMessage, terminalDispatchOutcome) => {
           if (!assistantMessage.text.trim()) {
             return;
           }
@@ -7345,12 +7269,12 @@ function createReplyToThread(deps) {
           let slackTs;
           await beforeFirstResponsePost();
           try {
-            if (channelId && threadTs && thread.adapter.name === "slack") {
+            if (channelId && thread.adapter.name === "slack") {
               slackTs = await sendSlackReply({
                 channelId,
                 conversationId,
                 text: assistantMessage.text,
-                threadTs
+                ...threadTs ? { threadTs } : {}
               });
             } else {
               for (const text of splitSlackReplyText(assistantMessage.text)) {
@@ -7379,6 +7303,8 @@ function createReplyToThread(deps) {
             });
           }
           assistantMessageDelivered = true;
+          acceptedDeliveryId = slackTs;
+          options.onTurnDeliveryAccepted?.(slackTs);
           const recordedMessageId = recordDeliveredAssistantMessage({
             conversation: preparedState.conversation,
             sessionId: turnId,
@@ -7410,6 +7336,35 @@ function createReplyToThread(deps) {
               "Failed to persist an accepted Slack assistant message"
             );
           }
+          if (slackTs && options.execution?.dispatch?.id) {
+            try {
+              await persistWithRetry(
+                () => recordAgentTurnSessionSummary({
+                  channelName,
+                  conversationId,
+                  destination,
+                  destinationVisibility,
+                  dispatchId: options.execution?.dispatch?.id,
+                  resultMessageId: slackTs,
+                  sessionId: turnId,
+                  sliceId: 1,
+                  source,
+                  startedAtMs: message.metadata.dateSent.getTime(),
+                  ...terminalDispatchOutcome ? { dispatchOutcome: terminalDispatchOutcome } : {},
+                  state: terminalDispatchOutcome ? "failed" : "running",
+                  surface: options.execution?.surface ?? "slack"
+                })
+              );
+            } catch (error) {
+              logException(
+                error,
+                "agent_turn_delivery_receipt_persist_failed",
+                turnTraceContext,
+                {},
+                "Failed to persist accepted turn delivery receipt"
+              );
+            }
+          }
           boundaryFailureCode = "agent_run_failed";
         };
         try {
@@ -7570,19 +7525,20 @@ function createReplyToThread(deps) {
             },
             routing: {
               credentialContext,
-              actor,
+              actor: options.execution ? executionActor : actor,
               slackConversation,
               source,
               destination,
               destinationVisibility,
-              surface: "slack",
+              surface: options.execution?.surface ?? "slack",
+              dispatch: options.execution?.dispatch,
               toolChannelId,
               slackActionToken
             },
             policy: {
               configuration: preparedState.configuration,
               channelConfiguration: preparedState.channelConfiguration,
-              authorizationFlowMode: message.author.isBot === true ? "disabled" : void 0,
+              authorizationFlowMode: options.execution?.authorizationFlowMode ?? (message.author.isBot === true ? "disabled" : void 0),
               turnDeadlineAtMs: getTurnRequestDeadline()?.deadlineAtMs
             },
             state: {
@@ -7624,6 +7580,8 @@ function createReplyToThread(deps) {
             }
           });
           if (outcome.status === "awaiting_auth") {
+            await recordDispatchOutcome("blocked", "failed");
+            options.onTurnOutcome?.({ outcome: "blocked" });
             if (!actor) {
               const authFailureEventId = logException(
                 new Error(
@@ -7675,6 +7633,7 @@ function createReplyToThread(deps) {
             return;
           }
           if (outcome.status === "suspended") {
+            options.onTurnOutcome?.({ outcome: "awaiting_resume" });
             if (options.shouldYield?.()) {
               shouldPersistFailureState = false;
               throw new CooperativeTurnYieldError();
@@ -7730,6 +7689,10 @@ function createReplyToThread(deps) {
             finalizedFailureEventId = finalized.eventId;
             await deliverAssistantMessage({ text: reply.text });
           }
+          const turnResult = reply.diagnostics.outcome === "success" ? { outcome: "completed" } : {
+            errorMessage: reply.diagnostics.errorMessage ?? `Agent turn ended with ${reply.diagnostics.outcome}.`,
+            outcome: "failed"
+          };
           runResultHandled = true;
           shouldPersistFailureState = false;
           boundaryFailureCode = "agent_run_failed";
@@ -7761,10 +7724,14 @@ function createReplyToThread(deps) {
                 source,
                 sessionId: turnId,
                 sliceId: 1,
+                dispatchOutcome: reply.diagnostics.outcome === "success" ? "completed" : "failed",
+                ...options.execution?.dispatch && turnResult.errorMessage ? { errorMessage: turnResult.errorMessage } : {},
+                ...acceptedDeliveryId ? { resultMessageId: acceptedDeliveryId } : {},
                 messages: reply.piMessages,
                 modelId: reply.diagnostics.modelId,
                 actor: executionActor,
-                surface: "slack"
+                surface: options.execution?.surface ?? "slack",
+                dispatchId: options.execution?.dispatch?.id
               });
             } else if (conversationId) {
               await recordAgentTurnSessionSummary({
@@ -7780,6 +7747,10 @@ function createReplyToThread(deps) {
                 destination,
                 destinationVisibility,
                 source,
+                surface: options.execution?.surface ?? "slack",
+                dispatchId: options.execution?.dispatch?.id,
+                dispatchOutcome: reply.diagnostics.outcome === "success" ? "completed" : "failed",
+                ...acceptedDeliveryId ? { resultMessageId: acceptedDeliveryId } : {},
                 traceId: getActiveTraceId()
               });
             }
@@ -7816,6 +7787,7 @@ function createReplyToThread(deps) {
           }
           preparedState.conversation = completedState.conversation;
           persistedAtLeastOnce = true;
+          options.onTurnOutcome?.(turnResult);
           if (!lifecycleTerminalized && conversationId) {
             if (reply.diagnostics.outcome === "success") {
               await deps.services.turnLifecycle.complete({
@@ -7901,6 +7873,9 @@ function createReplyToThread(deps) {
           shouldPersistFailureState = true;
           const classifiedFailure = getConversationTurnBoundaryError(error);
           const failureCause = classifiedFailure?.cause ?? error;
+          if (failureCause instanceof AuthorizationFlowDisabledError || failureCause instanceof PluginCredentialFailureError) {
+            terminalDispatchFailureOutcome = "blocked";
+          }
           const failureCode = classifiedFailure?.failureCode ?? boundaryFailureCode;
           const failureEventId = classifiedFailure?.eventId ?? logException(
             failureCause,
@@ -7914,8 +7889,31 @@ function createReplyToThread(deps) {
             after: latestArtifacts
           });
           if (createdCanvasUrl) {
+            const dispatchOutcome = terminalDispatchFailureOutcome ?? "failed";
+            const errorMessage = failureCause instanceof Error ? failureCause.message : "Agent turn failed after creating a canvas";
             const recoveryText = buildCanvasRecoveryReply(createdCanvasUrl);
-            await deliverAssistantMessage({ text: recoveryText });
+            await deliverAssistantMessage(
+              { text: recoveryText },
+              dispatchOutcome
+            );
+            if (conversationId) {
+              const sessionRecord = await getAgentTurnSessionRecord(
+                conversationId,
+                turnId
+              );
+              if (sessionRecord) {
+                await failAgentTurnSessionRecord({
+                  conversationId,
+                  expectedVersion: sessionRecord.version,
+                  sessionId: turnId,
+                  errorMessage
+                });
+              }
+            }
+            options.onTurnOutcome?.({
+              errorMessage,
+              outcome: dispatchOutcome
+            });
             markTurnClosed({
               conversation: preparedState.conversation,
               nowMs: Date.now(),
@@ -7970,6 +7968,11 @@ function createReplyToThread(deps) {
                   destination,
                   destinationVisibility,
                   source,
+                  surface: options.execution?.surface ?? "slack",
+                  dispatchId: options.execution?.dispatch?.id,
+                  ...options.execution?.dispatch && terminalDispatchFailureOutcome ? {
+                    dispatchOutcome: terminalDispatchFailureOutcome
+                  } : {},
                   traceId: getActiveTraceId()
                 });
                 const sessionRecord = await getAgentTurnSessionRecord(
@@ -8171,12 +8174,14 @@ function createPrepareTurnState(deps) {
     const conversation = coerceThreadConversationState(existingState);
     const conversationId = args.context.threadId ?? args.context.runId;
     await hydrateConversationMessages({ conversation, conversationId });
-    const channelConfiguration = getChannelConfigurationService(args.thread);
+    const channelConfiguration = args.channelConfiguration ?? getChannelConfigurationService(args.thread);
     const configuration = await channelConfiguration.resolveValues();
-    await seedConversationBackfill(args.thread, conversation, {
-      messageId: args.message.id,
-      messageCreatedAtMs: args.message.metadata.dateSent.getTime()
-    });
+    if (!args.skipBackfill) {
+      await seedConversationBackfill(args.thread, conversation, {
+        messageId: args.message.id,
+        messageCreatedAtMs: args.message.metadata.dateSent.getTime()
+      });
+    }
     for (const queued of args.queuedMessages ?? []) {
       const queuedMessage = toConversationMessage({
         entry: queued.message,
@@ -8243,6 +8248,94 @@ function createPrepareTurnState(deps) {
   };
 }
 
+// src/chat/slack/dispatch-turn.ts
+import { Message as Message3, ThreadImpl as ThreadImpl3 } from "chat";
+function createSlackDispatchTurnRunner(options) {
+  return async function runSlackDispatchTurn(dispatch, hooks) {
+    const state = getStateAdapter();
+    await state.connect();
+    const conversationId = getDispatchConversationId(dispatch);
+    const adapter = options.getSlackAdapter();
+    const message = new Message3({
+      id: getDispatchInputMessageId(dispatch.id),
+      threadId: conversationId,
+      text: dispatch.input,
+      attachments: [],
+      formatted: {
+        type: "root",
+        children: [
+          {
+            type: "paragraph",
+            children: [{ type: "text", value: dispatch.input }]
+          }
+        ]
+      },
+      metadata: {
+        dateSent: new Date(dispatch.createdAtMs),
+        edited: false
+      },
+      raw: {
+        channel: dispatch.destination.channelId,
+        team: dispatch.destination.teamId
+      },
+      author: {
+        userId: dispatch.actor.name,
+        userName: dispatch.actor.name,
+        fullName: dispatch.actor.name,
+        isBot: true,
+        isMe: false
+      }
+    });
+    message.isMention = true;
+    const thread = new ThreadImpl3({
+      adapter,
+      stateAdapter: state,
+      id: conversationId,
+      channelId: dispatch.destination.channelId,
+      channelVisibility: dispatch.destinationVisibility === "public" ? "workspace" : "private",
+      currentMessage: message,
+      initialMessage: message,
+      isDM: dispatch.destination.channelId.startsWith("D"),
+      isSubscribedContext: true
+    });
+    let outcome;
+    let errorMessage;
+    let resultMessageTs;
+    const routing = buildDispatchRoutingContext(dispatch);
+    await options.replyToThread(thread, message, {
+      ack: hooks.ack,
+      destination: dispatch.destination,
+      execution: {
+        authorizationFlowMode: "disabled",
+        channelConfiguration: options.getChannelConfiguration(
+          dispatch.destination.channelId
+        ),
+        credentialContext: routing.credentialContext,
+        destinationVisibility: dispatch.destinationVisibility,
+        dispatch: routing.dispatch,
+        skipProviderDefaultConfig: true,
+        source: dispatch.source,
+        surface: routing.surface,
+        turnId: getDispatchTurnId(dispatch.id)
+      },
+      onTurnDeliveryAccepted: (messageId) => {
+        resultMessageTs = messageId;
+      },
+      onTurnOutcome: (result) => {
+        outcome = result.outcome;
+        errorMessage = result.errorMessage;
+      },
+      shouldYield: hooks.shouldYield,
+      skipBackfill: true
+    });
+    return {
+      ...errorMessage ? { errorMessage } : {},
+      ...outcome ? { outcome } : {},
+      ...resultMessageTs ? { resultMessageTs } : {}
+    };
+  };
+}
+
 // src/chat/app/factory.ts
 async function persistAssistantContextChannelId(args) {
   const currentArtifacts = coerceThreadArtifactsState(
@@ -8287,7 +8380,7 @@ function createSlackRuntime(options) {
     resolveUserAttachments: services.visionContext.resolveUserAttachments,
     services: services.replyExecutor
   });
-  return createSlackTurnRuntime({
+  const runtime = createSlackTurnRuntime({
     assistantUserName: botConfig.userName,
     cancelEventSubscriptions: cancelSubscriptions,
     modelId: standardModelId(botConfig),
@@ -8406,6 +8499,14 @@ function createSlackRuntime(options) {
       });
     }
   });
+  return {
+    ...runtime,
+    runDispatchTurn: createSlackDispatchTurnRunner({
+      getChannelConfiguration: getChannelConfigurationServiceById,
+      getSlackAdapter: options.getSlackAdapter,
+      replyToThread
+    })
+  };
 }
 
 // src/chat/slack/adapter.ts
@@ -8464,7 +8565,7 @@ async function failSessionRecordBestEffort(args) {
     );
   }
 }
-async function persistFailedReplyState(sessionRecord) {
+async function persistFailedReplyState(sessionRecord, errorMessage = "Paused agent run failed while continuing") {
   const currentState = await getPersistedThreadState(
     sessionRecord.conversationId
   );
@@ -8484,7 +8585,7 @@ async function persistFailedReplyState(sessionRecord) {
   });
   await failSessionRecordBestEffort({
     sessionRecord,
-    errorMessage: "Paused agent run failed while continuing"
+    errorMessage
   });
   await persistThreadStateById(sessionRecord.conversationId, {
     conversation
@@ -8542,22 +8643,35 @@ async function failUnresumableContinuation(args) {
     sessionId: args.summary.sessionId,
     errorMessage: args.errorMessage
   });
+  if (args.summary.dispatchId) {
+    await recordAgentTurnSessionSummary({
+      actor: args.summary.actor,
+      conversationId: args.conversationId,
+      destination: args.summary.destination,
+      dispatchId: args.summary.dispatchId,
+      dispatchOutcome: "failed",
+      sessionId: args.summary.sessionId,
+      sliceId: args.summary.sliceId,
+      source: args.summary.source,
+      state: "failed",
+      surface: args.summary.surface
+    });
+  }
 }
 async function continueSlackAgentRun(payload, options, runOptions = {}) {
   const thread = parseSlackThreadId(payload.conversationId);
-  if (!thread) {
-    throw new Error(
-      `Agent continuation requires a Slack thread conversation id, got "${payload.conversationId}"`
-    );
-  }
+  const destination = requireSlackDestination(
+    payload.destination,
+    "Agent continuation"
+  );
   const scheduleAgentContinue2 = options.scheduleAgentContinue ?? scheduleAgentContinue;
   const resumeTurn = options.resumeTurn ?? resumeSlackTurn;
   return await resumeTurn({
     messageText: "",
     conversationId: payload.conversationId,
     turnId: payload.sessionId,
-    channelId: thread.channelId,
-    threadTs: thread.threadTs,
+    channelId: thread?.channelId ?? destination.channelId,
+    ...thread?.threadTs ? { threadTs: thread.threadTs } : {},
     lockKey: payload.conversationId,
     agentRunner: options.agentRunner,
     scheduleSessionCompletedPluginTasks: options.scheduleSessionCompletedPluginTasks,
@@ -8581,8 +8695,14 @@ async function continueSlackAgentRun(payload, options, runOptions = {}) {
           conversationId: payload.conversationId
         });
         const artifacts = coerceThreadArtifactsState(currentState);
-        const userMessage = getTurnUserMessage(conversation, payload.sessionId);
-        if (!userMessage?.author?.userId) {
+        const dispatchId = activeSessionRecord.dispatchId ?? options.routingContext?.dispatch?.id;
+        const dispatchUserMessage = dispatchId ? conversation.messages.find(
+          (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}"`
           );
@@ -8591,27 +8711,24 @@ async function continueSlackAgentRun(payload, options, runOptions = {}) {
           return false;
         }
         const channelConfiguration = getChannelConfigurationServiceById(
-          thread.channelId
+          destination.channelId
         );
-        const conversationContext = buildConversationContext(conversation, {
+        const conversationContext = dispatchId ? void 0 : buildConversationContext(conversation, {
           excludeMessageId: userMessage.id
         });
         const sandboxRef = getPersistedSandboxState(currentState);
-        const destination = requireSlackDestination(
-          payload.destination,
-          "Slack continuation"
-        );
-        const systemActor = activeSessionRecord.actor?.platform === "system" ? activeSessionRecord.actor : void 0;
         let actor;
         let credentialContext;
-        if (systemActor) {
+        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: userMessage.author.userId
+            userId: userActorId
           });
           if (!actor) {
             await failStrandedSessionWithFallback({
@@ -8640,27 +8757,49 @@ async function continueSlackAgentRun(payload, options, runOptions = {}) {
         const turnMessages = activeSessionRecord.turnStartMessageIndex === void 0 ? [] : activeSessionRecord.piMessages.slice(
           activeSessionRecord.turnStartMessageIndex
         );
+        const recordDispatchOutcome = async (dispatchOutcome) => {
+          const dispatchId2 = options.routingContext?.dispatch?.id;
+          if (!dispatchId2) {
+            return;
+          }
+          await recordAgentTurnSessionSummary({
+            conversationId: payload.conversationId,
+            destination: payload.destination,
+            destinationVisibility: options.routingContext?.destinationVisibility,
+            dispatchId: dispatchId2,
+            dispatchOutcome,
+            sessionId: payload.sessionId,
+            sliceId: activeSessionRecord.sliceId,
+            source: activeSessionRecord.source,
+            state: "failed",
+            surface: options.routingContext?.surface ?? "slack"
+          });
+        };
         return {
           messageText: userMessage.text,
+          sliceId: activeSessionRecord.sliceId,
           messageTs: getTurnUserSlackMessageTs(userMessage),
           inputMessageIds: [userMessage.id],
           initialStatus: latestReportedProgress(turnMessages),
           replyContext: {
             input: {
-              conversationContext,
+              ...conversationContext ? { conversationContext } : {},
               // Pi history is SQL-authoritative: the resumed run reads its
-              // session record first and falls back to the step projection.
-              piMessages: await loadProjection({
+              // exact dispatch session so unrelated conversation input cannot
+              // gain system authority. Interactive turns retain their merged
+              // projection so queued steering remains visible.
+              piMessages: dispatchId ? activeSessionRecord.piMessages : await loadProjection({
                 conversationId: payload.conversationId
               }),
               ...getTurnUserReplyAttachmentContext(userMessage)
             },
             routing: {
+              ...options.routingContext,
               credentialContext,
-              ...actor ? { actor } : {},
+              ...options.routingContext?.actor ?? actor ? { actor: options.routingContext?.actor ?? actor } : {},
               destination: payload.destination,
               source: activeSessionRecord.source,
-              toolChannelId: artifacts.assistantContextChannelId ?? thread.channelId
+              toolChannelId: artifacts.assistantContextChannelId ?? destination.channelId
             },
             policy: {
               channelConfiguration
@@ -8686,8 +8825,12 @@ async function continueSlackAgentRun(payload, options, runOptions = {}) {
               reply
             });
           },
-          onFailure: async () => {
-            await persistFailedReplyState(activeSessionRecord);
+          onFailure: async (error) => {
+            await persistFailedReplyState(
+              activeSessionRecord,
+              error instanceof Error ? error.message : String(error)
+            );
+            await recordDispatchOutcome("failed");
           },
           onPostDeliveryCommitFailure: async () => {
             await failAgentTurnSessionRecord({
@@ -8696,12 +8839,14 @@ async function continueSlackAgentRun(payload, options, runOptions = {}) {
               sessionId: activeSessionRecord.sessionId,
               errorMessage: "Continued agent reply was delivered but completion state did not persist"
             });
+            await recordDispatchOutcome("failed");
           },
           onAuthPause: async () => {
             await persistAuthPauseTurnState({
               sessionId: payload.sessionId,
               threadStateId: payload.conversationId
             });
+            await recordDispatchOutcome("blocked");
             logWarn(
               "agent_continue_reparked_for_auth",
               {},
@@ -8739,6 +8884,20 @@ async function failStrandedSessionWithFallback(args) {
     sessionId: args.sessionRecord.sessionId,
     errorMessage: args.errorMessage
   });
+  if (args.sessionRecord.dispatchId) {
+    await recordAgentTurnSessionSummary({
+      actor: args.sessionRecord.actor,
+      conversationId: args.conversationId,
+      destination: args.sessionRecord.destination,
+      dispatchId: args.sessionRecord.dispatchId,
+      dispatchOutcome: "failed",
+      sessionId: args.sessionRecord.sessionId,
+      sliceId: args.sessionRecord.sliceId,
+      source: args.sessionRecord.source,
+      state: "failed",
+      surface: args.sessionRecord.surface
+    });
+  }
   const currentState = await getPersistedThreadState(args.conversationId);
   const conversation = coerceThreadConversationState(currentState);
   await hydrateConversationMessages({
@@ -8757,10 +8916,6 @@ async function failStrandedSessionWithFallback(args) {
     updateConversationStats
   });
   await persistThreadStateById(args.conversationId, { conversation });
-  const thread = parseSlackThreadId(args.conversationId);
-  if (!thread) {
-    return;
-  }
   const eventName = "agent_turn_stranded_session_failed";
   const eventId = logException(
     new Error(args.errorMessage),
@@ -8772,9 +8927,14 @@ async function failStrandedSessionWithFallback(args) {
     },
     "Stranded running agent session terminally failed"
   );
+  const thread = parseSlackThreadId(args.conversationId);
+  const channelId = thread?.channelId ?? requireSlackDestination(
+    args.sessionRecord.destination,
+    "Stranded agent continuation"
+  ).channelId;
   await postSlackMessage({
-    channelId: thread.channelId,
-    threadTs: thread.threadTs,
+    channelId,
+    ...thread?.threadTs ? { threadTs: thread.threadTs } : {},
     text: buildTurnFailureResponse(
       requireTurnFailureEventId(eventId, eventName)
     )
@@ -8984,21 +9144,41 @@ function createProductionConversationWorkOptions(options) {
     getSlackAdapter: getProductionSlackAdapter,
     services
   });
-  return {
+  const queue = getVercelConversationWorkQueue();
+  const slackWorker = createSlackConversationWorker({
+    getSlackAdapter: getProductionSlackAdapter,
     conversationStore,
-    queue: getVercelConversationWorkQueue(),
-    run: createSlackConversationWorker({
-      getSlackAdapter: getProductionSlackAdapter,
-      conversationStore,
-      resumeAwaitingContinuation: async (conversationId, runOptions) => await resumeAwaitingSlackContinuation(
-        conversationId,
+    resumeAwaitingContinuation: async (conversationId, runOptions) => await resumeAwaitingSlackContinuation(
+      conversationId,
+      {
+        agentRunner,
+        scheduleSessionCompletedPluginTasks: services.replyExecutor?.scheduleSessionCompletedPluginTasks
+      },
+      runOptions
+    ),
+    runtime
+  });
+  const dispatchWorker = createAgentDispatchConversationWorker({
+    resumeTurn: async (dispatch, hooks) => {
+      await resumeAwaitingSlackContinuation(
+        getDispatchConversationId(dispatch),
         {
           agentRunner,
+          inputMessageIds: getDispatchInputMessageIds(dispatch.id),
+          routingContext: buildDispatchRoutingContext(dispatch),
           scheduleSessionCompletedPluginTasks: services.replyExecutor?.scheduleSessionCompletedPluginTasks
         },
-        runOptions
-      ),
-      runtime
+        { shouldYield: hooks.shouldYield }
+      );
+    },
+    runTurn: runtime.runDispatchTurn
+  });
+  return {
+    conversationStore,
+    queue,
+    run: createAgentDispatchWorkRouter({
+      dispatchWorker,
+      fallbackWorker: slackWorker
     })
   };
 }
@@ -9501,7 +9681,9 @@ async function createApp(options) {
     return receiveLocalOAuthCredential(c.req.raw);
   });
   app.post("/api/internal/agent-dispatch", (c) => {
-    return POST(c.req.raw, waitUntil, { agentRunner });
+    return POST(c.req.raw, waitUntil, {
+      conversationWorkQueue: getVercelConversationWorkQueue()
+    });
   });
   let agentContinuePOST;
   let pluginTaskPOST;