@sentry/junior 0.267.0 → 0.269.0

package/dist/{list-1XQP-o6K.js → list-CGoQdXTp.js}

@@ -1,42 +1,41 @@
-import { $n as buildDeterministicTurnId, At as PluginCredentialFailureError, Bt as wasPendingAuthStopped, Ct as isHumanConversationMessage, Dt as turnHasReply, E as sameDefinitionValue, Et as recordDeliveredAssistantMessage, G as commitMessages, Gt as completeTurnRecord, Ht as loadTurnCheckpoint, Jn as trimTrailingAssistantMessages, Jt as listTurnSummaries, Kt as failTurnRecord, Ot as upsertConversationMessage, Pn as persistWithRetry, Pt as AuthorizationFlowDisabledError, Qn as buildDeterministicAssistantMessageId, Rt as clearPendingAuth, S as automationDefinition, St as getConversationMessageSlackTs, Tt as normalizeConversationText, Ut as saveTurnCheckpoint, W as commitAcceptedReply, Wt as abandonTurnRecord, X as loadTurnProjection, Y as loadProjection, Yt as recordTurnSummary, _ as parseEventAutomationRow, bt as createConversationMemoryService, c as withScheduledAutomationLock, cr as isExperimentalFeatureEnabled, dr as configValueSchema, dt as persistConversationMessages, f as deleteEventAutomation, gt as fallbackShortTitle, h as listDeletedEventAutomationsCreatedBy, i as readScheduledAutomation, j as automationEventCatalog, jn as buildTurnErrorResponse, mt as resolveConversationTitle, nr as getSubscribedReplyPreflightDecision, nt as recordAuthorizationCompleted, o as saveScheduledAutomationInLock, ot as recordSubscribedReplyRoute, pr as piMessageFromHistoryItem, pt as persistConversationMessageSummaries, q as loadConversationProjection, qt as getTurnRecord, r as parseScheduledAutomationRow, rr as getThreadStopDecision, tr as decideSubscribedThreadReply, ut as hydrateConversationMessages, vt as appendThreadContextMessages, w as listAutomationVersions, wt as markConversationMessage, xt as estimateConversationContextTokens, yt as buildConversationContext, z as registeredEventTriggerProblems } from "./tasks-0ilmuCux.js";
-import { a as completeText, p as escapeXml, r as completeDecision, y as isProviderRetryError } from "./client-BjgbMawj.js";
-import { c as getSlackClientSecret, i as getChatConfig, l as getSlackSigningSecret, n as botConfig, o as getSlackBotToken, s as getSlackClientId, v as normalizeSlackEmojiName, y as createS3AttachmentStorage } from "./config-CdB6yJj5.js";
-import { B as isRecord, E as withSpan, H as toOptionalString, S as setTags, T as withLogContext, V as toOptionalNumber, b as setSpanAttributes, f as logError, h as logWarn, m as logInfo, n as createChatSdkLogger, o as getActiveTraceContext, p as logException, s as getActiveTraceId, t as buildTurnFailureResponse, y as setSentryUser } from "./logging-DuZ1A4ab.js";
+import { $t as appendThreadContextMessages, An as recordTurnSummary, At as loadProjection, Cn as loadTurnCheckpoint, Dn as failTurnRecord, En as completeTurnRecord, Et as commitMessages, Gt as hydrateConversationMessages, Ir as decideSubscribedThreadReply, Jr as piMessageFromHistoryItem, Jt as persistConversationMessageSummaries, Kr as configValueSchema, Kt as persistConversationMessages, Lr as getSubscribedReplyPreflightDecision, Lt as recordAuthorizationCompleted, Nr as buildDeterministicAssistantMessageId, On as getTurnRecord, Ot as loadConversationProjection, Pr as buildDeterministicTurnId, Rr as getThreadStopDecision, Tn as abandonTurnRecord, Tt as commitAcceptedReply, Ur as isExperimentalFeatureEnabled, Vt as recordSubscribedReplyRoute, Yt as resolveConversationTitle, Zt as fallbackShortTitle, _ as markDispatchCompleted, a as confirmDispatchMailboxAppend, an as markConversationMessage, cn as turnHasReply, d as getDispatchTurnId, dn as PluginCredentialFailureError, en as buildConversationContext, fr as buildTurnErrorResponse, g as markDispatchBlocked, h as markDispatchAwaitingResume, hn as AuthorizationFlowDisabledError, hr as persistWithRetry, i as claimDispatchMailboxAppend, in as isHumanConversationMessage, j as readAutomationTitlesByConversationId, jt as loadTurnProjection, kn as listTurnSummaries, kr as trimTrailingAssistantMessages, l as getDispatchInputMessageId, ln as upsertConversationMessage, n as resolveTurnSessionRouting, nn as estimateConversationContextTokens, on as normalizeConversationText, p as isTerminalDispatchStatus, rn as getConversationMessageSlackTs, s as getDispatchConversationId, sn as recordDeliveredAssistantMessage, t as resolveConversationRouting, tn as createConversationMemoryService, u as getDispatchRecord, v as markDispatchFailed, wn as saveTurnCheckpoint, xn as wasPendingAuthStopped, y as markDispatchRunning, yn as clearPendingAuth } from "./turn-session-routing-BqO0qXLk.js";
+import { a as completeText, p as escapeXml, r as completeDecision, y as isProviderRetryError } from "./client-Cqf4TboL.js";
+import { c as getSlackClientSecret, i as getChatConfig, l as getSlackSigningSecret, n as botConfig, o as getSlackBotToken, s as getSlackClientId, v as normalizeSlackEmojiName, y as createS3AttachmentStorage } from "./config-CPsE4T5L.js";
+import { B as isRecord, E as withSpan, H as toOptionalString, S as setTags, T as withLogContext, V as toOptionalNumber, b as setSpanAttributes, f as logError, h as logWarn, m as logInfo, n as createChatSdkLogger, o as getActiveTraceContext, p as logException, s as getActiveTraceId, t as buildTurnFailureResponse, y as setSentryUser } from "./logging-n7knse-O.js";
 import { i as getActiveSpan, r as continueTrace } from "./sentry-MDkYAVPV.js";
 import { o as modelIdForProfile, r as defaultModelId } from "./model-profile-Bg8EoCKD.js";
-import { a as isUserActor, d as parseSlackTeamId, i as isActorUserId, l as parseSlackChannelId, n as createSlackActor, o as parseActorUserId, p as parseSlackMessageTs, r as createSlackResumeActor, t as createActor } from "./actor-DZSokpwj.js";
-import { T as addAgentTurnUsage, V as requireSlackDestination, _ as loadConversationSlackTenantIds, b as locationFromRow, f as getConversationStore, g as withConversationEventLock, k as hasAgentTurnUsage, m as getSqlExecutor, p as getDb, u as getConversationEventStore, w as parseSessionSource, z as createSlackDestination } from "./viewer-DrN3oC2X.js";
-import { c as juniorIdentities, d as juniorDestinations, l as juniorUsers, o as conversationReadColumns, s as juniorConversations } from "./agent-invocations-CxKldAeB.js";
-import { a as juniorAutomationRuns, f as juniorConversationBriefs, h as juniorConversationEvents, s as juniorAutomations, v as juniorCodeChanges } from "./executor-VYrx_K4w.js";
-import { d as contextProvenance, p as instructionProvenanceFor } from "./history-C84mlAwO.js";
-import { d as actorLogContext, f as credentialContextForActor } from "./registry-FQutO926.js";
-import { B as resolveSlackChannelIdFromThreadId, H as listThreadReplies, J as describeEventAutomationTrigger, L as parseSlackThreadId, R as readSlackRawMessageContext, V as getConversationInfo, Y as effectiveTaskOutcomes, at as conversationSubtreeColumns, b as renderBlockText, ct as buildSteeringPiMessage, i as buildAuthPauseResponse, it as conversationSubtree, lt as withoutSavedSteeringMessages, mt as shouldEmitDevAgentTrace, n as executeAgentRun, p as latestProgressStatus, r as createContextCompactor, t as createAgentRunner, ut as RetryableDeliveryError, w as storeAttachment, y as renderAttachmentText, z as resolveSlackChannelIdFromMessage } from "./agent-runner-DgNATN4D.js";
-import { $ as postSlackMessage, $t as downloadPrivateSlackFile, Bn as conversationNotArchivedForEmail, Fn as conversationArchiveTimes, Ft as cancelSubscriptions, G as normalizeSlackReplyMarkdown, Hn as viewerConversationMembership, In as conversationArchivedForEmail, J as truncateStatusText, K as normalizeSlackStatusText, Kn as buildSentryConversationUrl, Ln as conversationArchivedForUser, Nn as createPluginLogger, Pn as readConversationAccessFromSql, Qt as SlackActionError, Rn as conversationHasParticipantUser, U as escapeSlackMrkdwnText, Vn as conversationNotArchivedForUser, W as formatSlackLink, Xn as recordSlackAttachment, Y as addReactionToMessage, Yn as readAttachmentVisionSummary, Zt as verifyTimerWatchCredentialSubject, an as normalizeSlackConversationId, ar as createPluginCache, dn as JUNIOR_THREAD_STATE_TTL_MS, et as removeReactionFromMessage, fn as getDashboardConversationLink, in as isDmChannel, ir as lookupSlackUser, l as getPluginSlackConversationLink, n as createUserTokenStore, nn as getSlackClient, on as runWithSlackInstallationToken, p as getPlugins, pn as getDashboardObjectIconLink, qn as getSlackFileId, sn as withSlackRetries, tn as getHeaderString, tr as listConversationAnnotationsById, zn as conversationIsMemberRoot } from "./credentialed-CIGwoLU2.js";
-import { a as MUTATION_LOCK_TTL_MS, c as withLock, i as getStateAdapter, o as acquireActiveLock } from "./adapter-BybMEezj.js";
-import { W as readMessageAttachments, g as conversationFeedSchema, q as isVisionImageMediaType } from "./conversation-DSo310Ps.js";
-import { a as EVENT_SYSTEM_ACTOR, o as isEventConversationMessage } from "./prompt-BW9jFsqZ.js";
-import { B as ConversationTurnBoundaryError, G as isCooperativeTurnYieldError, H as TurnInputCommitLostError, J as markTurnClosed, K as isTurnInputCommitLostError, U as TurnInputDeferredError, V as CooperativeTurnYieldError, W as getConversationTurnBoundaryError, X as markTurnFailed, Y as markTurnCompleted, Z as startActiveTurn, q as isTurnInputDeferredError } from "./store-6EetVP-m.js";
-import { n as getAssistantReplyText } from "./assistant-reply-CT7VcXQe.js";
-import { C as maybePostAutomatedTurnLimitNotice, M as runDispatchOutcome, O as deliversFinalText, c as isEventMailboxMetadata, d as getEventCatalog, i as skipInputBeforeConversationStop, k as finishedRunReply, l as renderEventBatchText, s as eventBatchMessageEvents, u as timerWatchCredentialSubject, w as recordFinishedTurnForAutomatedLimit, x as joinMailboxText } from "./session-stop-DkOjt46_.js";
-import { a as getVercelConversationWorkQueue, f as getTurnRequestDeadline } from "./job-queue-C0BZSa7r.js";
-import { D as stopConversationWork, g as getConversationWorkState, h as getConversation, m as ensureConversationWake, n as appendAndEnqueueExclusiveInboundMessage, r as appendAndEnqueueInboundMessage, w as requestConversationWork } from "./store-DvNZIsCr.js";
-import { j as eventAutomationTriggerSchema, l as automationListQuerySchema } from "./automation-CmeFBSEh.js";
-import { c as sumUtcHoursIntoSixHours, m as healthReportSchema, t as webMessageId } from "./web-message-id-CJSUiksE.js";
-import { A as readAutomationExecutions, D as readAutomationExecutionStatusDays, E as readAutomationExecutionHours, M as readAutomationTitlesByConversationId, O as readAutomationExecutionStatusHours, S as emptyAutomationRunWindows, T as readAutomationExecutionDays, _ as markDispatchBlocked, a as claimDispatchMailboxAppend, b as markDispatchRunning, c as getDispatchConversationId, d as getDispatchRecord, f as getDispatchTurnId, g as markDispatchAwaitingResume, j as readAutomationRuns, k as readAutomationExecutionSummaries, l as getDispatchIdForConversation, m as isTerminalDispatchStatus, n as scheduleSessionCompletedPluginTasks, o as confirmDispatchMailboxAppend, t as processPluginTask, u as getDispatchInputMessageId, v as markDispatchCompleted, w as readAutomationExecutionByConversationId, y as markDispatchFailed } from "./task-runner-B-PD_JOj.js";
-import { a as withAgentInvocationResultActors, c as resolveMailboxTurnWork, d as legacyWebMailboxMetadataSchema, i as startAgentInvocationsForChildInput, l as sourceFromTurnInput, o as getAuthPausedConversationTurnId, s as getEventBatchDelayMs, t as enqueueAgentInvocationResult, u as turnInputFactsFromConversationMessage } from "./result-B9e9ATOU.js";
-import { n as getTurnLifecycle, t as ConversationTurnLifecycleService } from "./turn-lifecycle-OzLIwvi1.js";
-import { i as resolveAgentInvocationId, o as AgentRunError, s as executeTurn, t as createAgentInvocationWorker } from "./work-DUQoNcqP.js";
-import { a as persistThreadState, i as persistThreadRuntimeState, n as getPersistedSandboxState, o as persistThreadStateById, r as getPersistedThreadState, s as coerceThreadConversationState, t as getLocationConfigurationService } from "./thread-state-DRmdJ2QN.js";
-import { c as deleteWebAuthorization, d as createPausedTurns, f as getPausedTurnRequest, h as getTurnAuthorization, m as wakePausedTurn, s as createWebAuthorization } from "./connections-RE_65jzK.js";
-import { n as resolveTurnSessionRouting } from "./turn-session-routing-Dyut9l7Y.js";
-import { t as bindMessageAgent } from "./message-NKSbbnA6.js";
-import { t as bindSpawnAgent } from "./spawn-BHuqN14f.js";
-import { a as persistAuthPauseTurnState, c as getTurnUserSlackMessageTs, d as loadPendingMessageCards, i as completeAuthPauseTurn, l as buildDeliveredTurnStatePatch, n as getAgentTurnDiagnosticsAttributes, o as getTurnUserMessage, r as requireTurnFailureEventId, s as getTurnUserReplyAttachmentContext, t as finalizeFailedTurnReplyWithEvent, u as getInterruptionMarker } from "./turn-failure-response-G11cs2gE.js";
-import { r as storeInputImages } from "./images-CecjXAAz.js";
+import { f as parseSlackTeamId, i as isActorUserId, m as parseSlackMessageTs, n as createSlackActor, o as isUserActor, r as createSlackResumeActor, s as parseActorUserId, t as createActor, u as parseSlackChannelId } from "./actor-CP9K2Idu.js";
+import { C as getSqlExecutor, E as loadConversationSlackTenantIds, H as parseSessionSource, M as resolveActorIdentityId, N as saveActorAvatar, S as getDb, T as withConversationEventLock, U as addAgentTurnUsage, Y as createSlackDestination, Z as requireSlackDestination, f as identityAvatarUrl, h as readUserAvatarUrls, k as locationFromRow, q as hasAgentTurnUsage, x as getConversationStore, y as getConversationEventStore } from "./viewer-DSbD6DF6.js";
+import { c as juniorIdentities, d as juniorDestinations, l as juniorUsers, o as conversationReadColumns, s as juniorConversations } from "./agent-invocations-C1RNOCs8.js";
+import { S as juniorCodeChanges, g as juniorConversationBriefs, y as juniorConversationEvents } from "./executor-CNS7ONt-.js";
+import { g as instructionProvenanceFor, m as contextProvenance, r as isVisionImageMediaType } from "./media-85PDJxO_.js";
+import { d as actorLogContext, f as credentialContextForActor } from "./registry-By36_xsm.js";
+import { Et as withoutSavedSteeringMessages, F as getConversationInfo, I as listThreadReplies, M as readSlackRawMessageContext, N as resolveSlackChannelIdFromMessage, Nt as shouldEmitDevAgentTrace, P as resolveSlackChannelIdFromThreadId, St as conversationSubtreeColumns, Tt as buildSteeringPiMessage, b as renderBlockText, ct as webActorFromEmail, et as deliverReviewItemChange, i as buildAuthPauseResponse, j as parseSlackThreadId, k as runWithSlackInstallation, kt as RetryableDeliveryError, lt as resolveConversationDestination, mt as storeAttachment, n as executeAgentRun, ot as createConversationId, p as latestProgressStatus, r as createContextCompactor, st as recordWebConversationActivity, t as createAgentRunner, xt as conversationSubtree, y as renderAttachmentText } from "./agent-runner-CrDrPUtY.js";
+import { An as normalizeSlackConversationId, Ar as lookupSlackUser, Cn as SlackActionError, Dn as getSlackClient, Dr as listConversationAnnotationsById, Dt as removeReactionFromMessage, E as listReplyActionItems, En as getHeaderString, F as isOnlyAssignee, In as JUNIOR_THREAD_STATE_TTL_MS, M as canActOnReviewItem, Mn as withSlackRetries, P as canReadReviewItem, Sn as verifyTimerWatchCredentialSubject, Sr as recordSlackAttachment, _t as normalizeSlackStatusText, ar as createPluginLogger, b as closeReviewItem, bt as addReactionToMessage, cr as conversationArchivedForEmail, dr as conversationIsMemberRoot, fr as conversationNotArchivedForEmail, jr as createPluginCache, k as takeReviewItem, kn as isDmChannel, lr as conversationArchivedForUser, mr as viewerConversationMembership, n as createUserTokenStore, on as cancelSubscriptions, or as readConversationAccessFromSql, p as getPlugins, pr as conversationNotArchivedForUser, sr as conversationArchiveTimes, ur as conversationHasParticipantUser, w as getReviewItem, wn as downloadPrivateSlackFile, xr as readAttachmentVisionSummary, yr as getSlackFileId, yt as truncateStatusText, z as reviewItemReaderForUser } from "./credentialed-BU-OW7HP.js";
+import { a as withLock, n as MUTATION_LOCK_TTL_MS, r as acquireActiveLock } from "./locks-D-0h111u.js";
+import { r as getStateAdapter } from "./adapter-2-CG25be.js";
+import { W as readMessageAttachments, g as conversationFeedSchema } from "./conversation-CTpD_PGk.js";
+import { a as EVENT_SYSTEM_ACTOR, o as isEventConversationMessage } from "./prompt-BlQB0QQt.js";
+import { B as ConversationTurnBoundaryError, G as isCooperativeTurnYieldError, H as TurnInputCommitLostError, J as markTurnClosed, K as isTurnInputCommitLostError, U as TurnInputDeferredError, V as CooperativeTurnYieldError, W as getConversationTurnBoundaryError, X as markTurnFailed, Y as markTurnCompleted, Z as startActiveTurn, q as isTurnInputDeferredError } from "./store-1DVhoKOL.js";
+import { r as getAssistantReplyText } from "./interruption-marker-g6Xup3Fk.js";
+import { C as maybePostAutomatedTurnLimitNotice, D as recordFinishedTurnForAutomatedLimit, I as runDispatchOutcome, M as finishedRunReply, N as postsRunNotices, T as sendSlackReply, c as isEventMailboxMetadata, i as skipInputBeforeConversationStop, j as deliversFinalText, l as renderEventBatchText, s as eventBatchMessageEvents, u as timerWatchCredentialSubject, w as resolveSlackReplyTarget, x as joinMailboxText } from "./session-stop-BQW_iFcd.js";
+import { _ as normalizeUserInputAnswer, g as isEmptyUserInputAnswer } from "./reporting-window-CVarfId9.js";
+import { a as getVercelConversationWorkQueue, f as getTurnRequestDeadline } from "./job-queue-DI-k-Bbk.js";
+import { D as stopConversationWork, g as getConversationWorkState, h as getConversation, m as ensureConversationWake, r as appendAndEnqueueInboundMessage, w as requestConversationWork } from "./store-DCo2n5iJ.js";
+import { t as healthReportSchema } from "./reporting-schema-CZREhYc-.js";
+import { a as withAgentInvocationResultActors, c as resolveMailboxTurnWork, d as legacyWebMailboxMetadataSchema, l as sourceFromTurnInput, n as enqueueAgentInvocationResult, o as getAuthPausedConversationTurnId, s as getEventBatchDelayMs, t as createChildConversationWorker, u as turnInputFactsFromConversationMessage } from "./result-BemsOMOO.js";
+import { n as getTurnLifecycle, t as ConversationTurnLifecycleService } from "./turn-lifecycle-bf2fIYi_.js";
+import { a as AgentRunError, o as executeTurn } from "./work-BE_qTYGi.js";
+import { a as persistThreadStateById, i as persistThreadRuntimeState, n as getPersistedSandboxState, o as coerceThreadConversationState, r as getPersistedThreadState, t as getLocationConfigurationService } from "./thread-state-CHy8LS0C.js";
+import { c as deleteWebAuthorization, d as createPausedTurns, f as getPausedTurnRequest, h as getTurnAuthorization, m as wakePausedTurn, s as createWebAuthorization } from "./connections-upFXLmhG.js";
+import { t as bindMessageAgent } from "./message-BpaWd8TT.js";
+import { t as bindSpawnAgent } from "./spawn-ChCm46i-.js";
+import { n as scheduleSessionCompletedPluginTasks, t as processPluginTask } from "./task-runner-cA6yjn_E.js";
+import { a as persistAuthPauseTurnState, c as getTurnUserSlackMessageTs, i as completeAuthPauseTurn, l as buildDeliveredTurnStatePatch, n as getAgentTurnDiagnosticsAttributes, o as getTurnUserMessage, r as requireTurnFailureEventId, s as getTurnUserReplyAttachmentContext, t as finalizeFailedTurnReplyWithEvent, u as loadPendingMessageCards } from "./turn-failure-response-Dr7erLWs.js";
 import { z } from "zod";
 import { createHash } from "node:crypto";
-import { and, asc, count, desc, eq, exists, inArray, isNotNull, isNull, ne, notInArray, or, sql } from "drizzle-orm";
-import { conversationSidebarAnnotationSchema, createSlackSource, createWebSource, localDestinationSchema, objectFactFields, objectPresentation, objectTypeSchema } from "@sentry/junior-plugin-api";
+import { and, asc, desc, eq, inArray, isNotNull, isNull, ne, or, sql } from "drizzle-orm";
+import { conversationSidebarAnnotationSchema, createSlackSource, objectTypeSchema } from "@sentry/junior-plugin-api";
 import { alias } from "drizzle-orm/pg-core";
 import { del, get, put } from "@vercel/blob";
 import { Message, ThreadImpl, stringifyMarkdown } from "chat";
@@ -80,7 +79,7 @@ function buildDispatchRoutingContext(dispatch) {
 	};
 }
 /** Build the stable mailbox work item for one agent dispatch. */
-function buildAgentDispatchInboundMessage(dispatch, nowMs = Date.now()) {
+function buildAgentDispatchInboundMessage(dispatch, nowMs = Date.now(), authorIdentityId) {
 	return {
 		conversationId: getDispatchConversationId(dispatch),
 		createdAtMs: dispatch.createdAtMs,
@@ -89,6 +88,7 @@ function buildAgentDispatchInboundMessage(dispatch, nowMs = Date.now()) {
 		inboundMessageId: getDispatchInputMessageId(dispatch.id),
 		input: {
 			text: "[plugin dispatch]",
+			...authorIdentityId ? { authorIdentityId } : void 0,
 			metadata: {
 				dispatchId: dispatch.id,
 				kind: "agent_dispatch"
@@ -112,7 +112,7 @@ async function enqueueAgentDispatch(dispatch, options) {
 		sessionSource: claimedDispatch.source
 	});
 	await appendAndEnqueueInboundMessage({
-		message: buildAgentDispatchInboundMessage(claimedDispatch, nowMs),
+		message: buildAgentDispatchInboundMessage(claimedDispatch, nowMs, await resolveActorIdentityId(getSqlExecutor(), claimedDispatch.actor)),
 		conversationStore: options.conversationStore,
 		nowMs,
 		queue: options.queue,
@@ -380,207 +380,198 @@ function createAttachmentStorage(config) {
 		default: throw new Error(`Unsupported attachment storage provider: ${String(config.provider)}`);
 	}
 }
-// src/chat/slack/automation-card.ts
-function preview(text, length) {
-	const compact = text.replace(/\s+/g, " ").trim();
-	return compact.length > length ? `${compact.slice(0, length - 1)}…` : compact;
-}
-/** Show an Automation as a native Work Object, not an operation receipt. */
-function renderSlackAutomationCard(card) {
-	const title = preview(card.title, 160);
-	const iconUrl = getDashboardObjectIconLink("workflow");
-	const trigger = preview(card.trigger, 500);
-	const warning = card.warning ? preview(card.warning, 500) : null;
-	const text = [
-		"Automation",
-		card.url ? formatSlackLink(card.url, title) : escapeSlackMrkdwnText(title),
-		escapeSlackMrkdwnText(trigger),
-		warning ? escapeSlackMrkdwnText(warning) : null
-	].filter(Boolean).join("\n");
-	if (!card.url) return {
-		entity: null,
-		text
-	};
-	return {
-		text,
-		entity: {
-			entity_type: "slack#/entities/item",
-			external_ref: {
-				id: card.id,
-				type: "automation"
-			},
-			url: card.url,
-			entity_payload: {
-				attributes: {
-					title: { text: title },
-					display_type: "Automation",
-					product_icon: iconUrl ? {
-						url: iconUrl,
-						alt_text: "Automation"
-					} : void 0
-				},
-				custom_fields: [{
-					key: "trigger",
-					label: "When",
-					type: "string",
-					value: trigger,
-					long: true
-				}, ...warning ? [{
-					key: "warning",
-					label: "Needs attention",
-					type: "string",
-					value: warning,
-					long: true
-				}] : []]
-			}
-		}
+// src/chat/review-items/actions.ts
+/** An expected failure of a person action, for the API to report. */
+var ReviewItemActionError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "ReviewItemActionError";
+		this.code = code;
+	}
+};
+/** Read one Review item that a User can see, or fail as not found. */
+async function readReviewItemForUser(user, id) {
+	const item = await getReviewItem(getDb(), id);
+	if (!item || !canReadReviewItem(item, reviewItemReaderForUser(user))) throw new ReviewItemActionError("not_found", "Review item not found.");
+	return item;
+}
+function closedStatus(action) {
+	return action === "dismiss" ? "dismissed" : "done";
+}
+/** The change that one person action makes, for messages and notes. */
+function reviewItemChange(action, user) {
+	if (action === "take") return {
+		kind: "taken",
+		user
 	};
-}
-// src/chat/slack/object-card.ts
-function descriptionPreview(value) {
-	const text = value?.replace(/\r\n/g, "\n").trim() ?? "";
-	const preview = text.split("\n").slice(0, 6).join("\n").slice(0, 500);
-	return preview.length < text.length ? `${preview.slice(0, 499).trimEnd()}…` : preview;
-}
-/** Render a compact Task or Item preview, or the saved facts for its detail panel. */
-function renderSlackObjectCard(card, conversationId, surface = "preview") {
-	if (card.objectType === "automation" && card.plugin === "junior") return renderSlackAutomationCard({
-		id: card.key,
-		title: card.title,
-		url: card.url,
-		trigger: card.trigger ?? "",
-		warning: card.warning ?? null
-	});
-	const presentation = objectPresentation(card);
-	const type = card.displayType ?? presentation.label;
-	const iconUrl = getDashboardObjectIconLink(presentation.icon);
-	const title = card.title.slice(0, 160);
-	const details = surface === "details";
-	const deployment = card.objectType === "deployment" || card.objectType === "item" && card.facts?.type === "deployment";
-	const calendarEvent = card.objectType === "calendar_event";
-	const status = details || deployment || calendarEvent ? card.status : void 0;
-	const warning = details || deployment ? card.warning : void 0;
-	const facts = objectFactFields(card.facts).filter((field) => details || calendarEvent || deployment && field.key === "environment");
-	const description = details ? card.description?.trim() ?? "" : calendarEvent ? "" : descriptionPreview(card.description);
-	const text = [
-		escapeSlackMrkdwnText(type),
-		card.url ? formatSlackLink(card.url, title) : escapeSlackMrkdwnText(title),
-		escapeSlackMrkdwnText(card.label),
-		status ? escapeSlackMrkdwnText(status) : null,
-		description ? escapeSlackMrkdwnText(description) : null,
-		warning ? escapeSlackMrkdwnText(`Needs attention: ${warning}`) : null,
-		...facts.map((field) => escapeSlackMrkdwnText(`${field.label}: ${field.value}`))
-	].filter(Boolean).join("\n");
-	if (!card.url) return {
-		entity: null,
-		text
+	if (action === "submit") return {
+		kind: "submitted",
+		user
 	};
-	const task = card.objectType === "task";
-	const attributes = {
-		title: { text: title },
-		display_id: card.label,
-		display_type: type,
-		product_icon: iconUrl ? {
-			url: iconUrl,
-			alt_text: `${type}${status ? `: ${status}` : ""}`
-		} : void 0,
-		product_name: card.plugin
+	if (action === "complete") return {
+		kind: "completed",
+		user
 	};
-	const customFields = [
-		...description ? [{
-			key: "description",
-			label: "Description",
-			type: "string",
-			value: description,
-			long: true,
-			format: "markdown"
-		}] : [],
-		...facts.map((field) => ({
-			...field,
-			type: "string"
-		})),
-		...warning ? [{
-			key: "warning",
-			label: "Needs attention",
-			type: "string",
-			value: warning
-		}] : []
-	];
 	return {
-		text,
-		entity: {
-			...task ? {
-				entity_type: "slack#/entities/task",
-				entity_payload: {
-					attributes,
-					display_order: [...status ? ["status"] : [], ...customFields.map((field) => field.key)],
-					fields: status ? { status: { value: status } } : void 0,
-					custom_fields: customFields
-				}
-			} : {
-				entity_type: "slack#/entities/item",
-				entity_payload: {
-					attributes,
-					display_order: [...status ? ["status"] : [], ...customFields.map((field) => field.key)],
-					custom_fields: [...status ? [{
-						key: "status",
-						label: "Status",
-						type: "string",
-						value: status
-					}] : [], ...customFields]
-				}
-			},
-			external_ref: {
-				id: Buffer.from(JSON.stringify([
-					conversationId,
-					card.plugin,
-					card.key
-				]), "utf8").toString("base64url"),
-				type: "annotation"
-			},
-			url: card.url
-		}
+		kind: "dismissed",
+		user
 	};
 }
-// src/chat/slack/adapter-context.ts
-const initializedAdapters = /* @__PURE__ */ new WeakSet();
-async function getConnectedState$1(stateAdapter) {
-	const state = stateAdapter ?? getStateAdapter();
-	await state.connect();
-	return state;
-}
-/** Initialize the Slack adapter against the repository state adapter. */
-async function ensureSlackAdapterInitialized(args) {
-	if (initializedAdapters.has(args.adapter)) return;
-	const state = await getConnectedState$1(args.state);
-	await args.adapter.initialize({ getState: () => state });
-	if (args.adapter.defaultBotTokenProvider && !args.adapter.botUserId) throw new Error("Slack adapter initialized without a resolved bot user id");
-	initializedAdapters.add(args.adapter);
-}
-/** Verify a Slack request using the adapter's configured signing secret. */
-function verifySlackSignature(args) {
-	const verifySignature = args.adapter.verifySignature;
-	if (!verifySignature) throw new Error("Slack adapter does not expose signature verification");
-	return verifySignature.call(args.adapter, args.body, args.request.headers.get("x-slack-request-timestamp"), args.request.headers.get("x-slack-signature"));
-}
-/** Run Slack work with the installation token that matches the inbound event. */
-async function runWithSlackInstallation(args) {
-	await ensureSlackAdapterInitialized({
-		adapter: args.adapter,
-		state: args.state
+/**
+* Return whether a closed item is the result of this same action. An item
+* that a person's message closed never matches a card or desk action.
+*/
+function isSameClose(item, action, user) {
+	return item.closeReason !== "Replied in thread" && item.closedBy?.userId === user.id && item.status === closedStatus(action) && action === "submit" === Boolean(item.answer);
+}
+function submittedAnswer(item, answer) {
+	if (item.kind !== "action" || !item.request) throw new ReviewItemActionError("invalid", "Only an action item takes an answer.");
+	const normalized = normalizeUserInputAnswer(item.request, {
+		other: answer?.other,
+		requestId: item.id,
+		values: answer?.values ?? {}
 	});
-	const internals = args.adapter;
-	if (internals.defaultBotTokenProvider) return await args.task();
-	const installationId = args.installation.isEnterpriseInstall ? args.installation.enterpriseId : args.installation.teamId;
-	if (!installationId) throw new Error("Slack installation context is missing team id");
-	if (!internals.resolveTokenForTeam || !internals.requestContext) throw new Error("Slack adapter cannot resolve workspace installations");
-	const tokenContext = await internals.resolveTokenForTeam.call(args.adapter, installationId, args.installation.isEnterpriseInstall);
-	if (!tokenContext) throw new Error(`Slack installation token was not found for ${installationId}`);
-	return await internals.requestContext.run({
-		...tokenContext,
-		enterpriseId: args.installation.enterpriseId,
-		isEnterpriseInstall: args.installation.isEnterpriseInstall
-	}, () => runWithSlackInstallationToken(tokenContext.token, args.task));
+	if (isEmptyUserInputAnswer(normalized)) throw new ReviewItemActionError("invalid", "The answer is empty.");
+	return normalized;
+}
+/**
+* Do one person action on a Review item and tell its linked Conversations.
+* The first submit, complete, or dismiss closes the item for every
+* assignee. A retry of the same close sends any missing messages again and
+* succeeds, so a client can retry after a failure. With `firstCloseOnly`,
+* only the call that closes the item succeeds, and every other call gets a
+* conflict. Use it when the caller adds its own input for the action, such
+* as a card click in a chat thread, so one action adds one Turn.
+* `exceptConversationId` is the Conversation where the person acted. It gets
+* the person's input from its own surface, so it gets no message here.
+* `delivery` shows the change and sends the messages; see
+* `deliverReviewItemChange`.
+*/
+async function actOnReviewItem(args) {
+	const { action, user } = args;
+	const nowMs = args.nowMs ?? Date.now();
+	const db = getDb();
+	const item = await readReviewItemForUser(user, args.id);
+	if (action === "take") {
+		if (item.status !== "open") throw new ReviewItemActionError("conflict", "Review item is closed.");
+		if (!canActOnReviewItem(item, user.id)) throw new ReviewItemActionError("forbidden", "Only an assignee can take this item.");
+		if (!isOnlyAssignee(item, user.id) && !await takeReviewItem(db, {
+			id: item.id,
+			nowMs,
+			userId: user.id
+		})) throw new ReviewItemActionError("conflict", "Review item is closed.");
+		const taken = await readReviewItemForUser(user, item.id);
+		await deliverReviewItemChange({
+			change: reviewItemChange(action, user),
+			delivery: args.delivery,
+			exceptConversationId: args.exceptConversationId,
+			item: taken,
+			nowMs
+		});
+		return taken;
+	}
+	let closed = item;
+	let closedNow = false;
+	if (item.status === "open") {
+		if (!canActOnReviewItem(item, user.id)) throw new ReviewItemActionError("forbidden", "Only an assignee can act on this item.");
+		if (action === "complete" && item.kind === "action") throw new ReviewItemActionError("invalid", "An action item needs an answer. Submit it or dismiss it.");
+		const answer = action === "submit" ? submittedAnswer(item, args.answer) : void 0;
+		closedNow = await closeReviewItem(db, {
+			closedByUserId: user.id,
+			id: item.id,
+			nowMs,
+			status: closedStatus(action),
+			...answer ? { answer } : void 0
+		});
+		closed = await readReviewItemForUser(user, item.id);
+	}
+	if (args.firstCloseOnly ? !closedNow : !isSameClose(closed, action, user)) throw new ReviewItemActionError("conflict", "Review item is closed.");
+	await deliverReviewItemChange({
+		change: reviewItemChange(action, user),
+		delivery: args.delivery,
+		exceptConversationId: args.exceptConversationId,
+		item: closed,
+		nowMs
+	});
+	return closed;
+}
+/**
+* Return whether a reply from this User answers an open action item, or is
+* a retry of the reply from this User that closed it.
+*/
+function replyAnswers(item, user) {
+	if (item.status !== "open") return item.closedBy?.userId === user?.id;
+	if (item.assignedToEveryone) return false;
+	if (item.assignees.length === 0) return true;
+	return user !== void 0 && item.assignees.some((assignee) => assignee.userId === user.id);
+}
+/** Return the answer that the text of a person's message gives to an item. */
+function messageAnswer(item, text) {
+	if (!item.request) return void 0;
+	const answer = normalizeUserInputAnswer(item.request, {
+		other: text,
+		requestId: item.id,
+		values: {}
+	});
+	return isEmptyUserInputAnswer(answer) ? void 0 : answer;
+}
+/**
+* Close the open action items that a person answered with a reply in their
+* thread. Call it after the reply is saved to the Conversation, so the
+* reply always reaches the agent. Each item that it closes saves `text` as
+* its answer, so the item keeps what the person said.
+*
+* A reply closes an item only when all of these are true:
+* - The item is an open `action` item.
+* - The agent added it in this Conversation (`addedByConversationId`).
+* - The replier is an assigned User, or the item has no assignees. A Slack
+*   replier without a Junior User closes only items with no assignees.
+*
+* Items assigned to Everyone, or only to other people, stay open. They need
+* an answer on the card or the review desk. Each item closes as `done` with
+* `REVIEW_ITEM_REPLIED_REASON`, and the replier closes it. The reply itself
+* is the answer in this Conversation, so only the other linked
+* Conversations get a message. A click that closes the item first wins.
+* A retry of the reply, or a later reply from the same person, delivers
+* the items that it closed again: the cards show the close, and only the
+* missing messages go. Each message has a key, so a message that was sent
+* does not go again. `delivery` shows the change and sends the messages;
+* see `deliverReviewItemChange`.
+*/
+async function closeReviewItemsAnsweredByReply(args) {
+	const db = getDb();
+	const items = await listReplyActionItems(db, args.conversationId);
+	if (items.length === 0) return;
+	if (args.canAnswer && !await args.canAnswer()) return;
+	const user = await args.resolveUser();
+	const nowMs = args.nowMs ?? Date.now();
+	for (const item of items.filter((candidate) => replyAnswers(candidate, user))) {
+		let closedItem = item;
+		if (item.status === "open") {
+			const answer = messageAnswer(item, args.text);
+			if (!await closeReviewItem(db, {
+				...answer ? { answer } : void 0,
+				id: item.id,
+				nowMs,
+				reason: "Replied in thread",
+				status: "done",
+				...user ? { closedByUserId: user.id } : void 0
+			})) continue;
+			closedItem = await getReviewItem(db, item.id);
+			if (!closedItem) continue;
+		}
+		await deliverReviewItemChange({
+			change: {
+				kind: "replied",
+				who: user ? user.displayName ?? user.email : "A person"
+			},
+			delivery: args.delivery,
+			exceptConversationId: args.conversationId,
+			item: closedItem,
+			nowMs
+		});
+	}
 }
 // src/chat/slack/errors.ts
 /** Extract Slack's stable API error code from Web API errors. */
@@ -915,6 +906,7 @@ function combineTurnText(queuedMessages, latestText) {
 }
 // src/chat/services/message-actor-identity.ts
 const messageActors = /* @__PURE__ */ new WeakMap();
+const messageAuthorIdentityIds = /* @__PURE__ */ new WeakMap();
 function canonicalUserId(author, actor) {
 	const authorUserId = parseActorUserId(author.userId);
 	if (authorUserId && authorUserId !== actor.userId) throw new Error("Message actor user id mismatch");
@@ -945,6 +937,17 @@ function bindMessageActorIdentity(message, actor) {
 	applyActorToAuthor(message.author, currentActor);
 	return currentActor;
 }
+/**
+* Keep the author Identity id that ingress resolved, next to the Actor.
+* The Message write reads it, so the write does not guess the author again.
+*/
+function bindMessageAuthorIdentityId(message, authorIdentityId) {
+	if (authorIdentityId) messageAuthorIdentityIds.set(message, authorIdentityId);
+}
+/** Read the author Identity id that ingress bound to a Chat SDK message. */
+function getMessageAuthorIdentityId(message) {
+	return messageAuthorIdentityIds.get(message);
+}
 /** Read message identity without promoting adapter display fallbacks. */
 function getMessageActorIdentity(message) {
 	return messageActors.get(message) ?? actorFromAuthor(message.author);
@@ -1040,10 +1043,8 @@ function createSlackTurnRuntime(deps) {
 		return true;
 	};
 	const failConversationTurn = async (args) => {
-		const conversationId = getThreadId(args.thread, args.message) ?? getRunId(args.thread, args.message);
-		if (!conversationId) return;
 		await turnLifecycle.fail({
-			conversationId,
+			conversationId: args.conversationId,
 			createdAtMs: deps.now(),
 			eventId: args.eventId,
 			failureCode: args.failureCode,
@@ -1088,7 +1089,15 @@ function createSlackTurnRuntime(deps) {
 	};
 	const postFallbackErrorReplyWithLogging = async (args) => {
 		try {
-			await args.thread.post(buildTurnErrorResponse(args.error, args.eventId));
+			const channelId = getChannelId(args.thread, args.message);
+			if (!channelId) throw new Error("Slack fallback error reply requires a channel id");
+			const threadTs = getThreadTs(getThreadId(args.thread, args.message));
+			await sendSlackReply({
+				channelId,
+				conversationId: args.conversationId,
+				text: buildTurnErrorResponse(args.error, args.eventId),
+				...threadTs ? { threadTs } : void 0
+			});
 		} catch (postError) {
 			logException(postError, args.postFailureEventName, {
 				"app.slack.reply_stage": "error_fallback_post",
@@ -1144,14 +1153,14 @@ function createSlackTurnRuntime(deps) {
 		const completedAtMs = deps.now();
 		logSkippedSubscribedDecision(args);
 		if (args.preparedState) await deps.onSubscribedMessageSkipped({
-			thread: args.thread,
+			conversationId: args.conversationId,
 			message: args.message,
 			decision: args.decision,
 			preparedState: args.preparedState,
 			completedAtMs
 		});
 		else await deps.recordSkippedSubscribedTurn({
-			thread: args.thread,
+			conversationId: args.conversationId,
 			message: args.message,
 			decision: args.decision,
 			text: args.text,
@@ -1199,7 +1208,7 @@ function createSlackTurnRuntime(deps) {
 			});
 			logSkippedSubscribedDecision(skipped);
 			await deps.recordSkippedSteeringMessage({
-				thread: args.thread,
+				conversationId: args.conversationId,
 				message: skipped.message,
 				decision: skipped.decision,
 				text: skipped.text
@@ -1213,7 +1222,7 @@ function createSlackTurnRuntime(deps) {
 			while (args.pending.length > 0) {
 				const skipped = args.pending.shift();
 				await deps.recordSkippedSteeringMessage({
-					thread: args.thread,
+					conversationId: args.conversationId,
 					message: skipped.message,
 					decision: skipped.decision,
 					text: skipped.text
@@ -1227,6 +1236,7 @@ function createSlackTurnRuntime(deps) {
 	};
 	return {
 		async handleNewMention(thread, message, hooks) {
+			const conversationId = hooks.conversationId ?? thread.id;
 			const processingReactions = createProcessingReactionTracker(thread);
 			let processingReaction;
 			const skippedSteeringMessages = [];
@@ -1235,7 +1245,7 @@ function createSlackTurnRuntime(deps) {
 			const onTurnCompleted = async () => {
 				completed = true;
 				await flushSkippedSteeringMessagesBestEffort({
-					thread,
+					conversationId,
 					pending: skippedSteeringMessages,
 					context: logContext({
 						threadId: getThreadId(thread, message),
@@ -1289,6 +1299,7 @@ function createSlackTurnRuntime(deps) {
 						},
 						onSkipped: (skipped) => handleSkippedSteeringMessages({
 							beforeFirstResponsePost: hooks.beforeFirstResponsePost,
+							conversationId,
 							pending: skippedSteeringMessages,
 							skipped,
 							thread
@@ -1302,7 +1313,7 @@ function createSlackTurnRuntime(deps) {
 					await deps.executeSlackTurn(thread, message, {
 						explicitMention: true,
 						beforeFirstResponsePost: hooks.beforeFirstResponsePost,
-						conversationId: hooks.conversationId,
+						conversationId,
 						destination: hooks.destination,
 						queuedMessages,
 						ack,
@@ -1339,17 +1350,19 @@ function createSlackTurnRuntime(deps) {
 				let lifecycleError;
 				try {
 					await failConversationTurn({
+						conversationId,
 						eventId,
 						failureCode,
-						message,
-						thread
+						message
 					});
 				} catch (error) {
 					lifecycleError = error;
 				}
 				await hooks.beforeFirstResponsePost?.();
 				await postFallbackErrorReplyWithLogging({
+					conversationId,
 					thread,
+					message,
 					eventId,
 					error: failureCause,
 					postFailureEventName: "mention.handler.failure_reply_post.failed"
@@ -1359,7 +1372,7 @@ function createSlackTurnRuntime(deps) {
 				if (completed) await processingReactions.completeAll();
 				else {
 					await flushSkippedSteeringMessagesBestEffort({
-						thread,
+						conversationId,
 						pending: skippedSteeringMessages,
 						context: logContext({
 							threadId: getThreadId(thread, message),
@@ -1374,6 +1387,7 @@ function createSlackTurnRuntime(deps) {
 			}
 		},
 		async handleSubscribedMessage(thread, message, hooks) {
+			const conversationId = hooks.conversationId ?? thread.id;
 			const processingReactions = createProcessingReactionTracker(thread);
 			let processingReaction;
 			const skippedSteeringMessages = [];
@@ -1382,7 +1396,7 @@ function createSlackTurnRuntime(deps) {
 			const onTurnCompleted = async () => {
 				completed = true;
 				await flushSkippedSteeringMessagesBestEffort({
-					thread,
+					conversationId,
 					pending: skippedSteeringMessages,
 					context: logContext({
 						threadId: getThreadId(thread, message),
@@ -1418,6 +1432,7 @@ function createSlackTurnRuntime(deps) {
 						userText: replaceTopLevelText(content, strippedUserText)
 					};
 					const threadContext = {
+						conversationId,
 						threadId,
 						actorId,
 						channelId,
@@ -1450,7 +1465,7 @@ function createSlackTurnRuntime(deps) {
 							beforeFirstResponsePost: hooks.beforeFirstResponsePost
 						});
 						await skipSubscribedMessage({
-							thread,
+							conversationId,
 							message,
 							decision,
 							context: threadContext,
@@ -1468,7 +1483,7 @@ function createSlackTurnRuntime(deps) {
 					if (preflightDecision && !preflightDecision.shouldReply) {
 						const reason = preflightDecision.reasonDetail ? `${preflightDecision.reason}:${preflightDecision.reasonDetail}` : preflightDecision.reason;
 						await skipSubscribedMessage({
-							thread,
+							conversationId,
 							message,
 							decision: {
 								shouldReply: false,
@@ -1494,7 +1509,7 @@ function createSlackTurnRuntime(deps) {
 							beforeFirstResponsePost: hooks.beforeFirstResponsePost
 						});
 						await skipSubscribedMessage({
-							thread,
+							conversationId,
 							message,
 							decision,
 							context: threadContext,
@@ -1513,7 +1528,7 @@ function createSlackTurnRuntime(deps) {
 						queuedMessages
 					});
 					await deps.persistPreparedState({
-						thread,
+						conversationId,
 						preparedState
 					});
 					const decision = await deps.decideSubscribedReply({
@@ -1530,7 +1545,7 @@ function createSlackTurnRuntime(deps) {
 						beforeFirstResponsePost: hooks.beforeFirstResponsePost
 					})) {
 						await skipSubscribedMessage({
-							thread,
+							conversationId,
 							message,
 							decision,
 							context: threadContext,
@@ -1542,7 +1557,7 @@ function createSlackTurnRuntime(deps) {
 					}
 					if (!decision.shouldReply) {
 						await skipSubscribedMessage({
-							thread,
+							conversationId,
 							message,
 							decision,
 							context: threadContext,
@@ -1561,6 +1576,7 @@ function createSlackTurnRuntime(deps) {
 						},
 						onSkipped: (skipped) => handleSkippedSteeringMessages({
 							beforeFirstResponsePost: hooks.beforeFirstResponsePost,
+							conversationId,
 							pending: skippedSteeringMessages,
 							skipped,
 							thread
@@ -1586,7 +1602,7 @@ function createSlackTurnRuntime(deps) {
 					const toolInvocationHook = createToolInvocationHook(processingReaction, hooks);
 					await deps.executeSlackTurn(thread, message, {
 						explicitMention: Boolean(message.isMention),
-						conversationId: hooks.conversationId,
+						conversationId,
 						destination: hooks.destination,
 						preparedState,
 						beforeFirstResponsePost: hooks.beforeFirstResponsePost,
@@ -1625,17 +1641,19 @@ function createSlackTurnRuntime(deps) {
 				let lifecycleError;
 				try {
 					await failConversationTurn({
+						conversationId,
 						eventId,
 						failureCode,
-						message,
-						thread
+						message
 					});
 				} catch (error) {
 					lifecycleError = error;
 				}
 				await hooks.beforeFirstResponsePost?.();
 				await postFallbackErrorReplyWithLogging({
+					conversationId,
 					thread,
+					message,
 					eventId,
 					error: failureCause,
 					postFailureEventName: "subscribed_message.handler.failure_reply_post.failed"
@@ -1645,7 +1663,7 @@ function createSlackTurnRuntime(deps) {
 				if (completed) await processingReactions.completeAll();
 				else {
 					await flushSkippedSteeringMessagesBestEffort({
-						thread,
+						conversationId,
 						pending: skippedSteeringMessages,
 						context: logContext({
 							threadId: getThreadId(thread, message),
@@ -2125,6 +2143,7 @@ function restoreMessage(args) {
 	const message = Message.fromJSON(metadata.message);
 	message.attachments = message.attachments.map((attachment) => args.adapter.rehydrateAttachment(attachment));
 	rehydrateAttachmentFetchers(message);
+	bindMessageAuthorIdentityId(message, args.record.input.authorIdentityId);
 	return message;
 }
 async function bindSlackActorIdentities(args) {
@@ -2136,6 +2155,10 @@ async function bindSlackActorIdentities(args) {
 	await Promise.all([...byAuthorId].map(async ([authorId, messages]) => {
 		const profile = await args.lookupSlackUser(args.teamId, authorId);
 		await Promise.all(messages.map((message) => ensureSlackMessageActorIdentity(message, args.teamId, async () => profile)));
+		if (profile && messages.some(getMessageAuthorIdentityId)) await resolveActorIdentityId(getSqlExecutor(), createSlackActor(args.teamId, authorId, {
+			fullName: profile.fullName,
+			userName: profile.userName
+		}));
 	}));
 }
 function restoreThread(args) {
@@ -2297,6 +2320,7 @@ function createSlackConversationWorker(options) {
 /** Serialize a Slack message and the active trace into the durable mailbox. */
 function buildSlackInboundMessage(args) {
 	const authorId = requireSlackAuthorId(args.message);
+	const authorIdentityId = getMessageAuthorIdentityId(args.message);
 	const destination = createSlackDestination({
 		channelId: args.thread.channelId,
 		teamId: args.installation?.teamId
@@ -2319,6 +2343,7 @@ function buildSlackInboundMessage(args) {
 		input: {
 			text: args.message.text || " ",
 			authorId,
+			...authorIdentityId ? { authorIdentityId } : void 0,
 			attachments: args.message.attachments,
 			metadata: {
 				platform: "slack",
@@ -2775,9 +2800,11 @@ function toConversationMessage(args) {
 	const slackTs = getMessageTimestamp(args.entry);
 	const messageHasPotentialImageAttachment = hasPotentialImageAttachment(args.entry.attachments);
 	const imageAttachmentCount = messageHasPotentialImageAttachment ? countPotentialImageAttachments(args.entry.attachments) : 0;
+	const authorIdentityId = args.entry.author.isMe ? void 0 : getMessageAuthorIdentityId(args.entry);
 	return {
 		id: args.entry.id,
 		role: args.entry.author.isMe ? "assistant" : "user",
+		...authorIdentityId ? { authorIdentityId } : void 0,
 		text: resolveMessageText(args),
 		createdAtMs: args.entry.metadata.dateSent.getTime(),
 		author: {
@@ -2867,578 +2894,6 @@ function isAllowedSignInEmail(email, allowedDomains) {
 	const separator = normalized.lastIndexOf("@");
 	return allowedDomains.length > 0 && separator > 0 && isAllowedDomain(normalized.slice(separator + 1), allowedDomains);
 }
-// src/chat/automations/collection.ts
-/**
-* The web collection applies access before counts, filter options, and paging.
-* Keep its ownership rules aligned with the direct Automation reader. A public
-* Destination only grants access inside a viewer's linked Slack workspaces.
-*/
-function viewerAutomationCollection(user) {
-	const db = getDb();
-	const teamIds = user.identities.filter((identity) => identity.provider === "slack").flatMap((identity) => identity.providerTenantId ? [identity.providerTenantId] : []);
-	const automation = juniorAutomations;
-	const destination = juniorDestinations;
-	const isScheduled = eq(automation.kind, "scheduled");
-	const owned = inArray(automation.creatorIdentityId, user.identities.map((identity) => identity.id));
-	const publicDestination = sql`coalesce(${destination.visibility} = 'public', false)`;
-	const publicToViewer = and(inArray(automation.teamId, teamIds), publicDestination, ne(automation.status, "completed"));
-	const runs = juniorAutomationRuns;
-	const lastRunNeedsAttention = sql`coalesce((select ${runs.status} in ('failed', 'blocked') from ${runs}
-      where ${runs.automationId} = ${automation.id} and ${runs.status} in ('blocked', 'completed', 'failed') and ${runs.completedAtMs} is not null
-      order by ${runs.completedAtMs} desc, ${runs.id} desc limit 1), false)`;
-	return db.select({
-		kind: automation.kind,
-		id: automation.id,
-		title: automation.title,
-		createdAtMs: automation.createdAtMs,
-		state: sql`${automation.status}`.as("state"),
-		lastRunNeedsAttention: lastRunNeedsAttention.as("last_run_needs_attention"),
-		trigger: sql`${automation.record}->'trigger'`.as("trigger"),
-		owned: sql`${owned}`.as("owned"),
-		resource: sql`case when ${isScheduled} then '' else concat_ws(' ', ${automation.identifier}, ${automation.record}->'trigger'->>'label', ${automation.namespace}) end`.as("resource"),
-		creator: sql`${automation.teamId} || ':' || ${automation.creatorSlackUserId}`.as("creator"),
-		creatorLabel: sql`coalesce(nullif(trim(${automation.record}->'createdBy'->>'fullName'), ''), nullif(trim(${automation.record}->'createdBy'->>'userName'), ''), ${automation.creatorSlackUserId})`.as("creator_label"),
-		destination: sql`${automation.teamId} || ':' || ${automation.channelId}`.as("destination"),
-		destinationLabel: sql`coalesce(nullif(${destination.displayName}, ''), ${automation.channelId})`.as("destination_label"),
-		isPublic: publicDestination.as("is_public"),
-		instruction: automation.instruction
-	}).from(automation).leftJoin(destination, and(eq(destination.provider, "slack"), eq(destination.providerTenantId, automation.teamId), eq(destination.providerDestinationId, automation.channelId))).where(and(ne(automation.status, "deleted"), or(owned, publicToViewer))).as("accessible_automations");
-}
-/**
-* List the accessible event automations whose trigger cannot work with the
-* enabled plugins. `eventTriggerProblems` decides, the same check that the
-* tools and the dashboard use, so SQL does not keep its own copy of the rules.
-*/
-async function unavailableEventAutomationIds(collection) {
-	const catalog = automationEventCatalog(getEventCatalog());
-	return (await getDb().select({
-		id: collection.id,
-		trigger: collection.trigger
-	}).from(collection).where(eq(collection.kind, "event"))).flatMap((row) => {
-		const trigger = eventAutomationTriggerSchema.safeParse(row.trigger);
-		return trigger.success && registeredEventTriggerProblems(catalog, trigger.data).length === 0 ? [] : [row.id];
-	});
-}
-/** Read an SQL page and complete, access-scoped counts and filter options. */
-async function readAutomationCollection(user, input) {
-	const db = getDb();
-	const collection = viewerAutomationCollection(user);
-	const unavailableIds = await unavailableEventAutomationIds(collection);
-	const unavailable = unavailableIds.length > 0 ? inArray(collection.id, unavailableIds) : sql`false`;
-	const attention = and(notInArray(collection.state, ["paused", "completed"]), or(eq(collection.state, "blocked"), unavailable, eq(collection.lastRunNeedsAttention, true)));
-	const where = and(input.scope === "mine" ? eq(collection.owned, true) : input.scope === "public" ? eq(collection.isPublic, true) : input.scope === "attention" ? attention : void 0, input.type === "all" ? void 0 : eq(collection.kind, input.type), input.state === "all" ? void 0 : input.state === "unavailable" ? unavailable : eq(collection.state, input.state), input.creator ? eq(collection.creator, input.creator) : void 0, input.destination ? eq(collection.destination, input.destination) : void 0, input.q ? sql`strpos(lower(concat_ws(' ', ${collection.title}, ${collection.instruction}, ${collection.resource})), ${input.q.toLowerCase()}) > 0` : void 0);
-	const [totals, counts, creators, destinations] = await Promise.all([
-		db.select({ total: count() }).from(collection).where(where),
-		db.select({
-			all: count(),
-			mine: sql`count(*) filter (where ${collection.owned})::int`,
-			public: sql`count(*) filter (where ${collection.isPublic})::int`,
-			private: sql`count(*) filter (where not ${collection.isPublic})::int`
-		}).from(collection),
-		db.select({
-			value: collection.creator,
-			label: sql`min(${collection.creatorLabel})`
-		}).from(collection).groupBy(collection.creator).orderBy(sql`min(${collection.creatorLabel})`, collection.creator),
-		db.select({
-			value: collection.destination,
-			label: sql`min(${collection.destinationLabel})`
-		}).from(collection).groupBy(collection.destination).orderBy(sql`min(${collection.destinationLabel})`, collection.destination)
-	]);
-	const total = totals[0].total;
-	const page = Math.min(input.page, Math.max(1, Math.ceil(total / input.pageSize)));
-	const order = input.sort === "oldest" ? asc(collection.createdAtMs) : input.sort === "title" ? asc(sql`lower(coalesce(nullif(trim(${collection.title}), ''), ${collection.instruction}))`) : desc(collection.createdAtMs);
-	return {
-		rows: await db.select({
-			id: collection.id,
-			kind: collection.kind
-		}).from(collection).where(where).orderBy(order, desc(collection.id)).limit(input.pageSize).offset((page - 1) * input.pageSize),
-		total,
-		page,
-		pageSize: input.pageSize,
-		counts: counts[0],
-		creators,
-		destinations
-	};
-}
-// src/chat/automations/creator.ts
-/**
-* Return whether the user created the Automation. Both kinds store the
-* creating Junior identity, so one rule decides ownership.
-*/
-function isAutomationCreator(user, automation) {
-	return user.identities.some((identity) => identity.id === automation.creatorIdentityId);
-}
-// src/chat/scheduled-automations/personal.ts
-var PersonalScheduledAutomationNotFoundError = class extends Error {
-	constructor() {
-		super("Scheduled automation was not found.");
-		this.name = "PersonalScheduledAutomationNotFoundError";
-	}
-};
-/** Delete one scheduled automation created by the viewer. */
-async function deleteViewerScheduledAutomation(db, user, id, nowMs = Date.now()) {
-	await withScheduledAutomationLock(db, id, async (tx) => {
-		const task = await readScheduledAutomation(tx, id);
-		if (!task || task.status === "deleted" || !isAutomationCreator(user, task)) throw new PersonalScheduledAutomationNotFoundError();
-		await saveScheduledAutomationInLock(tx, {
-			...task,
-			nextRunAtMs: void 0,
-			runNowAtMs: void 0,
-			status: "deleted",
-			updatedAtMs: nowMs
-		}, task);
-	});
-}
-// src/chat/automations/read.ts
-const TASK_EXECUTION_LIST_LIMIT = 100;
-const AUTOMATION_VERSION_LIST_LIMIT = 100;
-function creatorLabel(creator) {
-	return creator.fullName?.trim() || (creator.userName?.trim() ? `@${creator.userName.trim()}` : "") || creator.slackUserId;
-}
-function creatorKey(teamId, slackUserId) {
-	return `${teamId}:${slackUserId}`;
-}
-async function creatorProfiles(candidates) {
-	const selectors = new Map(candidates.map(({ task }) => {
-		const teamId = task.destination.teamId;
-		const slackUserId = task.createdBy.slackUserId;
-		return [creatorKey(teamId, slackUserId), {
-			slackUserId,
-			teamId
-		}];
-	}));
-	if (selectors.size === 0) return /* @__PURE__ */ new Map();
-	const rows = await getDb().select({
-		avatarUrl: juniorIdentities.avatarUrl,
-		email: juniorUsers.primaryEmailNormalized,
-		emailVerified: juniorIdentities.emailVerified,
-		slackUserId: juniorIdentities.providerSubjectId,
-		teamId: juniorIdentities.providerTenantId
-	}).from(juniorIdentities).leftJoin(juniorUsers, eq(juniorUsers.id, juniorIdentities.userId)).where(and(eq(juniorIdentities.kind, "user"), eq(juniorIdentities.provider, "slack"), or(...[...selectors.values()].map((selector) => and(eq(juniorIdentities.providerTenantId, selector.teamId), eq(juniorIdentities.providerSubjectId, selector.slackUserId))))));
-	return new Map(rows.map((row) => [creatorKey(row.teamId, row.slackUserId), {
-		email: row.emailVerified ? row.email ?? void 0 : void 0,
-		avatarUrl: row.avatarUrl ?? void 0
-	}]));
-}
-function destinationKey(destination) {
-	return `${destination.teamId}:${destination.channelId}`;
-}
-function displayText(value, fallback) {
-	return value.trim() || fallback;
-}
-function taskDisplayTitle(title, instruction, fallback) {
-	const stored = title?.trim();
-	if (stored) return stored;
-	return fallbackShortTitle(instruction, fallback);
-}
-async function destinationDetails(destinations) {
-	const selectors = new Map(destinations.map((destination) => [destinationKey(destination), destination]));
-	if (selectors.size === 0) return /* @__PURE__ */ new Map();
-	const rows = await getDb().select({
-		displayName: juniorDestinations.displayName,
-		kind: juniorDestinations.kind,
-		providerDestinationId: juniorDestinations.providerDestinationId,
-		providerTenantId: juniorDestinations.providerTenantId,
-		visibility: juniorDestinations.visibility
-	}).from(juniorDestinations).where(or(...[...selectors.values()].map((destination) => and(eq(juniorDestinations.provider, "slack"), eq(juniorDestinations.providerTenantId, destination.teamId), eq(juniorDestinations.providerDestinationId, destination.channelId)))));
-	return new Map(rows.map((row) => {
-		const name = row.displayName?.trim();
-		const label = name ? row.kind === "channel" ? `#${name.replace(/^#/, "")}` : name : row.kind === "dm" ? "Direct message" : row.kind === "group" ? "Group message" : `Channel ${row.providerDestinationId}`;
-		return [`${row.providerTenantId}:${row.providerDestinationId}`, {
-			label,
-			visibility: row.visibility === "public" ? "public" : "private"
-		}];
-	}));
-}
-function executionSummaryFields(stats) {
-	return {
-		lastRunStatus: stats?.lastRunStatus,
-		...stats?.lastConversationId ? { lastConversationId: stats.lastConversationId } : void 0,
-		...stats?.lastExecutedAtMs ? { lastRunAt: new Date(stats.lastExecutedAtMs).toISOString() } : void 0,
-		costUsd: stats?.costUsd ?? emptyAutomationRunWindows(),
-		runs: stats?.runs ?? emptyAutomationRunWindows(),
-		totalRuns: stats?.totalRuns ?? 0
-	};
-}
-function scheduledAutomationSummary(task, ownedByViewer, destination, stats, creator) {
-	if (task.status === "deleted") throw new Error("Deleted scheduled automations cannot enter the Automations view");
-	const nextRunAtMs = task.status === "active" ? task.runNowAtMs ?? task.nextRunAtMs : void 0;
-	const instruction = displayText(task.task.text, "Untitled scheduled automation");
-	return {
-		createdAt: new Date(task.createdAtMs).toISOString(),
-		createdBy: creatorLabel(task.createdBy),
-		createdByEmail: creator?.email,
-		createdByAvatarUrl: creator?.avatarUrl,
-		destination: {
-			channelId: task.destination.channelId,
-			label: destination.label,
-			teamId: task.destination.teamId,
-			visibility: destination.visibility
-		},
-		id: task.id,
-		instruction,
-		kind: "scheduled",
-		...executionSummaryFields(stats),
-		...nextRunAtMs !== void 0 ? { nextRunAt: new Date(nextRunAtMs).toISOString() } : void 0,
-		ownedByViewer,
-		schedule: displayText(task.schedule.description, "Schedule unavailable"),
-		status: task.status,
-		statusReason: task.statusReason,
-		timezone: task.schedule.timezone,
-		credentialMode: task.credentialMode,
-		outcomes: effectiveTaskOutcomes(task.outcomes, task.destination),
-		title: taskDisplayTitle(task.title, instruction, "Untitled scheduled automation")
-	};
-}
-function eventAutomationSummary(task, ownedByViewer, destination, stats, creator) {
-	const instruction = task.task.text;
-	const catalog = getEventCatalog();
-	return {
-		createdAt: new Date(task.createdAtMs).toISOString(),
-		createdBy: creatorLabel(task.createdBy),
-		createdByEmail: creator?.email,
-		createdByAvatarUrl: creator?.avatarUrl,
-		destination: {
-			channelId: task.destination.channelId,
-			label: destination.label,
-			teamId: task.destination.teamId,
-			visibility: destination.visibility
-		},
-		id: task.id,
-		instruction,
-		kind: "event",
-		...executionSummaryFields(stats),
-		ownedByViewer,
-		resource: task.trigger.identifier ? `${task.trigger.label} · ${task.trigger.identifier}` : task.trigger.label,
-		source: task.trigger.namespace,
-		credentialMode: task.credentialMode,
-		outcomes: effectiveTaskOutcomes(task.outcomes, task.destination),
-		title: taskDisplayTitle(task.title, instruction, "Untitled event automation"),
-		status: task.status === "deleted" ? "active" : task.status,
-		statusReason: task.statusReason,
-		trigger: describeEventAutomationTrigger(task.trigger, catalog)
-	};
-}
-function viewerTeamIds(user) {
-	return [...new Set(user.identities.filter((identity) => identity.provider === "slack").map((identity) => identity.providerTenantId).filter((teamId) => Boolean(teamId)))];
-}
-/** Resolve an Automation the viewer owns or can read through a public Destination. */
-async function resolveViewerTaskCandidate(user, id) {
-	const [row] = await getDb().select().from(juniorAutomations).where(eq(juniorAutomations.id, id)).limit(1);
-	if (!row) return void 0;
-	let candidate;
-	if (row.kind === "scheduled") {
-		const task = parseScheduledAutomationRow(row);
-		if (!task) return void 0;
-		candidate = {
-			kind: "scheduled",
-			ownedByViewer: isAutomationCreator(user, task),
-			task
-		};
-	} else {
-		const task = parseEventAutomationRow(row);
-		candidate = {
-			kind: "event",
-			ownedByViewer: isAutomationCreator(user, task),
-			task
-		};
-	}
-	const { task } = candidate;
-	if (task.status === "deleted") return void 0;
-	if (candidate.ownedByViewer) return candidate;
-	const destination = (await destinationDetails([task.destination])).get(destinationKey(task.destination));
-	return viewerTeamIds(user).includes(task.destination.teamId) && destination?.visibility === "public" ? candidate : void 0;
-}
-/** Read one current Automation summary with the Automations view access rules. */
-async function readViewerAutomationSummary(user, id) {
-	const candidate = await resolveViewerTaskCandidate(user, id);
-	if (!candidate) return void 0;
-	return automationSummaryForCandidate(candidate);
-}
-async function automationSummaryForCandidate(candidate) {
-	const [destinations, creators, stats] = await Promise.all([
-		destinationDetails([candidate.task.destination]),
-		creatorProfiles([candidate]),
-		readAutomationExecutionSummaries([candidate.task.id])
-	]);
-	const destination = destinations.get(destinationKey(candidate.task.destination)) ?? {
-		label: `Channel ${candidate.task.destination.channelId}`,
-		visibility: "private"
-	};
-	const creator = creators.get(creatorKey(candidate.task.destination.teamId, candidate.task.createdBy.slackUserId));
-	if (candidate.kind === "scheduled") return scheduledAutomationSummary(candidate.task, candidate.ownedByViewer, destination, stats.get(candidate.task.id), creator);
-	return eventAutomationSummary(candidate.task, candidate.ownedByViewer, destination, stats.get(candidate.task.id), creator);
-}
-function emptyAutomationExecutionDay(date) {
-	return {
-		costUsd: 0,
-		date,
-		event: 0,
-		scheduled: 0
-	};
-}
-function emptyAutomationExecutionStatusDay(date) {
-	return {
-		blocked: 0,
-		completed: 0,
-		date,
-		failed: 0
-	};
-}
-function automationExecutionSixHours(hours, nowMs = Date.now()) {
-	return sumUtcHoursIntoSixHours({
-		empty: emptyAutomationExecutionDay,
-		hours,
-		nowMs
-	});
-}
-function automationExecutionStatusSixHours(hours, nowMs = Date.now()) {
-	return sumUtcHoursIntoSixHours({
-		empty: emptyAutomationExecutionStatusDay,
-		hours,
-		nowMs
-	});
-}
-/** Read a page from the full accessible Automation collection. */
-async function readViewerAutomations(user, input = automationListQuerySchema.parse({})) {
-	const { rows, ...page } = await readAutomationCollection(user, input);
-	const db = getDb();
-	const ids = rows.map((row) => row.id);
-	const stored = ids.length ? await db.select().from(juniorAutomations).where(inArray(juniorAutomations.id, ids)) : [];
-	const candidates = /* @__PURE__ */ new Map();
-	for (const row of stored) {
-		if (row.kind === "scheduled") {
-			const task = parseScheduledAutomationRow(row);
-			if (task && task.status !== "deleted") candidates.set(task.id, {
-				kind: "scheduled",
-				task,
-				ownedByViewer: isAutomationCreator(user, task)
-			});
-			continue;
-		}
-		const task = parseEventAutomationRow(row);
-		if (task.status !== "deleted") candidates.set(task.id, {
-			kind: "event",
-			task,
-			ownedByViewer: isAutomationCreator(user, task)
-		});
-	}
-	const selected = rows.flatMap((row) => {
-		const candidate = candidates.get(row.id);
-		return candidate ? [candidate] : [];
-	});
-	const [destinations, creators] = await Promise.all([destinationDetails(selected.map(({ task }) => task.destination)), creatorProfiles(selected)]);
-	const visible = selected.filter((candidate) => candidate.ownedByViewer || destinations.get(destinationKey(candidate.task.destination))?.visibility === "public");
-	const collection = viewerAutomationCollection(user);
-	const access = exists(getDb().select({ id: collection.id }).from(collection).where(eq(collection.id, juniorAutomationRuns.automationId)));
-	const [executionDays, executionHours, stats] = await Promise.all([
-		readAutomationExecutionDays(90, { access }),
-		readAutomationExecutionHours(168, { access }),
-		readAutomationExecutionSummaries(ids)
-	]);
-	const automations = visible.map((candidate) => {
-		const destination = destinations.get(destinationKey(candidate.task.destination)) ?? {
-			label: `Channel ${candidate.task.destination.channelId}`,
-			visibility: "private"
-		};
-		const creator = creators.get(creatorKey(candidate.task.destination.teamId, candidate.task.createdBy.slackUserId));
-		if (candidate.kind === "scheduled") return scheduledAutomationSummary(candidate.task, candidate.ownedByViewer, destination, stats.get(candidate.task.id), creator);
-		return eventAutomationSummary(candidate.task, candidate.ownedByViewer, destination, stats.get(candidate.task.id), creator);
-	});
-	return {
-		executionDays,
-		executionHours,
-		executionSixHours: automationExecutionSixHours(executionHours),
-		automations,
-		...page
-	};
-}
-/** Load deleted scheduled automations the viewer still owns, newest first. */
-async function readDeletedOwnedScheduledAutomations(user) {
-	const identityIds = user.identities.map((identity) => identity.id);
-	if (identityIds.length === 0) return [];
-	return (await getDb().select().from(juniorAutomations).where(and(eq(juniorAutomations.kind, "scheduled"), eq(juniorAutomations.status, "deleted"), inArray(juniorAutomations.creatorIdentityId, identityIds))).orderBy(desc(juniorAutomations.createdAtMs), desc(juniorAutomations.id)).limit(TASK_EXECUTION_LIST_LIMIT)).map(parseScheduledAutomationRow).filter((task) => task?.status === "deleted");
-}
-/** Load deleted event automations the viewer still owns, newest first. */
-async function readDeletedOwnedEventAutomations(user) {
-	return await listDeletedEventAutomationsCreatedBy(getDb(), user, TASK_EXECUTION_LIST_LIMIT);
-}
-function automationTitleForRun(run, automationTitles) {
-	return automationTitles.get(`${run.kind}:${run.automationId}`) ?? run.title?.trim() ?? "Untitled task";
-}
-function addDeletedAutomationRun(args, automationTitles, automations) {
-	const key = `${args.kind}:${args.automationId}`;
-	if (automationTitles.has(key)) return;
-	automationTitles.set(key, args.title);
-	automations.push({
-		kind: args.kind,
-		automationId: args.automationId
-	});
-}
-/**
-* Read newest runs across live viewer-visible automations and deleted automations the
-* viewer owns. Deleted task rows stay available so history does not depend on
-* conversation actor membership.
-*/
-async function readViewerAutomationRuns(user) {
-	const [taskList, deletedScheduled, deletedEvent] = await Promise.all([
-		getDb().select().from(viewerAutomationCollection(user)),
-		readDeletedOwnedScheduledAutomations(user),
-		readDeletedOwnedEventAutomations(user)
-	]);
-	const automationTitles = /* @__PURE__ */ new Map();
-	const automations = [];
-	for (const task of taskList) {
-		automationTitles.set(`${task.kind}:${task.id}`, taskDisplayTitle(task.title ?? void 0, task.instruction, `Untitled ${task.kind} automation`));
-		automations.push({
-			kind: task.kind,
-			automationId: task.id
-		});
-	}
-	for (const task of deletedScheduled) {
-		const instruction = displayText(task.task.text, "Untitled scheduled automation");
-		addDeletedAutomationRun({
-			kind: "scheduled",
-			automationId: task.id,
-			title: taskDisplayTitle(task.title, instruction, "Untitled scheduled automation")
-		}, automationTitles, automations);
-	}
-	for (const task of deletedEvent) {
-		const instruction = displayText(task.task.text, "Untitled event automation");
-		addDeletedAutomationRun({
-			kind: "event",
-			automationId: task.id,
-			title: taskDisplayTitle(task.title, instruction, "Untitled event automation")
-		}, automationTitles, automations);
-	}
-	const runs = await readAutomationRuns({
-		automationIds: automations.map((automation) => automation.automationId),
-		limit: 101
-	});
-	return {
-		runs: runs.slice(0, TASK_EXECUTION_LIST_LIMIT).map((run) => ({
-			...run,
-			automationTitle: automationTitleForRun(run, automationTitles)
-		})),
-		truncated: runs.length > TASK_EXECUTION_LIST_LIMIT
-	};
-}
-var ViewerTaskNotFoundError = class extends Error {
-	constructor() {
-		super("Task was not found.");
-		this.name = "ViewerTaskNotFoundError";
-	}
-};
-/** Read one viewer-visible task and its newest terminal executions. */
-async function readViewerAutomationExecutions(user, id) {
-	const candidate = await resolveViewerTaskCandidate(user, id);
-	if (!candidate) throw new ViewerTaskNotFoundError();
-	const [automation, executions, executionDays, executionHours] = await Promise.all([
-		automationSummaryForCandidate(candidate),
-		readAutomationExecutions({
-			automationId: id,
-			limit: 101
-		}),
-		readAutomationExecutionStatusDays({ automationId: id }),
-		readAutomationExecutionStatusHours({ automationId: id })
-	]);
-	return {
-		executionDays,
-		executionHours,
-		executionSixHours: automationExecutionStatusSixHours(executionHours),
-		executions: executions.slice(0, TASK_EXECUTION_LIST_LIMIT),
-		automation,
-		truncated: executions.length > TASK_EXECUTION_LIST_LIMIT
-	};
-}
-/** Read saved definitions for one viewer-visible Automation, newest first. */
-async function readViewerAutomationVersions(user, id) {
-	const candidate = await resolveViewerTaskCandidate(user, id);
-	if (!candidate) throw new ViewerTaskNotFoundError();
-	const versions = await listAutomationVersions(getDb(), id, 101);
-	const current = automationDefinition(candidate.task);
-	const listed = versions.slice(0, AUTOMATION_VERSION_LIST_LIMIT);
-	const catalog = getEventCatalog();
-	return {
-		versions: listed.map((version) => version.kind === "event" ? {
-			...version,
-			trigger: describeEventAutomationTrigger(version.definition.trigger, catalog)
-		} : version),
-		activeVersion: listed.find(({ definition }) => sameDefinitionValue(definition, current))?.version ?? null,
-		truncated: versions.length > AUTOMATION_VERSION_LIST_LIMIT
-	};
-}
-/** Name the event in a trigger, such as "opened" for `pull_request.opened`. */
-function eventActionLabel(eventName) {
-	const [, ...action] = eventName.split(".");
-	return (action.length > 0 ? action : [eventName]).join(" ").replaceAll("_", " ");
-}
-/**
-* Read whose access one run used from its dispatch record. Return nothing when
-* the record is gone, because the Automation's current setting can differ.
-*/
-async function readRunCredential(dispatchId, creator) {
-	if (!dispatchId) return {};
-	const dispatch = await getDispatchRecord(dispatchId);
-	if (!dispatch) return {};
-	const subject = dispatch.credentialSubject;
-	if (!subject) return { credentialMode: "system" };
-	return {
-		credentialMode: "creator",
-		credentialUser: subject.userId === creator.slackUserId ? creatorLabel(creator) : subject.userId
-	};
-}
-/** Resolve the source task for one conversation when an Automation run links it. */
-async function readConversationSourceTask(args) {
-	const execution = await readAutomationExecutionByConversationId({ conversationId: args.conversationId });
-	if (!execution) return void 0;
-	const dispatchId = getDispatchIdForConversation(args.conversationId);
-	const base = {
-		kind: execution.kind,
-		...dispatchId ? { triggerMessageId: getDispatchInputMessageId(dispatchId) } : void 0
-	};
-	if (!args.viewer) return base;
-	const candidate = await resolveViewerTaskCandidate(args.viewer, execution.automationId);
-	if (!candidate) return base;
-	const credential = await readRunCredential(dispatchId, candidate.task.createdBy);
-	if (candidate.kind === "scheduled") {
-		const instruction = displayText(candidate.task.task.text, "Untitled scheduled automation");
-		const schedule = candidate.task.schedule.description.trim();
-		return {
-			...base,
-			...credential,
-			id: candidate.task.id,
-			kind: "scheduled",
-			label: instruction,
-			title: taskDisplayTitle(candidate.task.title, instruction, "Untitled scheduled automation"),
-			...schedule ? { triggerLabel: schedule } : void 0
-		};
-	}
-	const instruction = displayText(candidate.task.task.text, "Untitled event automation");
-	const { events, label } = candidate.task.trigger;
-	return {
-		...base,
-		...credential,
-		id: candidate.task.id,
-		kind: "event",
-		label: instruction,
-		title: taskDisplayTitle(candidate.task.title, instruction, "Untitled event automation"),
-		triggerLabel: events.length === 1 ? `${label} ${eventActionLabel(events[0])}` : label
-	};
-}
-/** Delete one viewer-owned scheduled or event automation. */
-async function deleteViewerTask(user, id) {
-	const candidate = await resolveViewerTaskCandidate(user, id);
-	if (!candidate?.ownedByViewer) throw new ViewerTaskNotFoundError();
-	if (candidate.kind === "scheduled") try {
-		await deleteViewerScheduledAutomation(getDb(), user, id);
-		return;
-	} catch (error) {
-		if (error instanceof PersonalScheduledAutomationNotFoundError) throw new ViewerTaskNotFoundError();
-		throw error;
-	}
-	await deleteEventAutomation(getDb(), id);
-}
 // src/chat/slack/assistant-thread/status-send.ts
 /**
 * Slack's assistant loading UI accepts both `status` and `loading_messages`,
@@ -3592,292 +3047,6 @@ function readSlackActionToken(message) {
 	const token = slackActionTokenSchema.safeParse(envelope.data.raw?.action_token);
 	return token.success ? token.data : void 0;
 }
-// src/chat/slack/cards.ts
-/** Select the Slack object renderer for a built-in card. */
-function renderSlackCard(card, conversationId) {
-	switch (card.kind) {
-		case "object": return renderSlackObjectCard(card, conversationId);
-		case "automation": return renderSlackAutomationCard(card);
-	}
-}
-// src/chat/slack/footer.ts
-/** Render compact reply attribution for the Slack footer. */
-function formatReplyAttribution(attribution) {
-	return attribution.detail ? `${attribution.label} · ${attribution.detail}` : attribution.label;
-}
-/**
-* Build the compact conversation footer for visible Slack reply surfaces.
-*
-* Detailed turn metrics stay in the dashboard instead of Slack-visible copy.
-*/
-function buildSlackReplyFooter(args) {
-	const items = [];
-	const conversationId = args.conversationId?.trim();
-	if (conversationId) {
-		const idItem = {
-			label: "ID",
-			value: conversationId
-		};
-		const conversationUrl = getPluginSlackConversationLink(conversationId)?.url ?? getDashboardConversationLink(conversationId) ?? buildSentryConversationUrl(conversationId);
-		if (conversationUrl) idItem.url = conversationUrl;
-		items.push(idItem);
-	}
-	return items.length > 0 || args.replyAttribution ? {
-		...args.replyAttribution ? { attribution: args.replyAttribution } : void 0,
-		items
-	} : void 0;
-}
-/** Build Slack blocks for a reply chunk using the Slack-flavored markdown block for the body. */
-function buildSlackReplyBlocks(text, footer) {
-	const blocks = text.trim() ? [{
-		type: "markdown",
-		text
-	}] : [];
-	if (footer && (footer.attribution || footer.items.length > 0)) {
-		const attributionElements = footer.attribution ? [{
-			type: "plain_text",
-			text: formatReplyAttribution(footer.attribution)
-		}] : [];
-		blocks.push({
-			type: "context",
-			elements: [...attributionElements, ...footer.items.map((item) => ({
-				type: "mrkdwn",
-				text: item.url ? `*${escapeSlackMrkdwnText(item.label)}:* ${formatSlackLink(item.url, item.value)}` : `*${escapeSlackMrkdwnText(item.label)}:* ${escapeSlackMrkdwnText(item.value)}`
-			}))]
-		});
-	}
-	return blocks.length ? blocks : void 0;
-}
-// src/chat/slack/output.ts
-const MAX_INLINE_CHARS = 2200;
-const MAX_INLINE_LINES = 45;
-const CONTINUED_MARKER = "\n\n[Continued below]";
-function countSlackLines(text) {
-	if (!text) return 0;
-	return text.split("\n").length;
-}
-function fitsInlineBudget(text, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
-	return text.length <= maxChars && countSlackLines(text) <= maxLines;
-}
-function findSplitIndex(text, maxChars) {
-	if (text.length <= maxChars) return text.length;
-	const bounded = text.slice(0, maxChars);
-	const newlineIndex = bounded.lastIndexOf("\n");
-	if (newlineIndex > 0) return newlineIndex;
-	const spaceIndex = bounded.lastIndexOf(" ");
-	if (spaceIndex > 0) return spaceIndex;
-	return maxChars;
-}
-function splitByLineBudget(text, maxLines) {
-	if (maxLines <= 0) return "";
-	const lines = text.split("\n");
-	if (lines.length <= maxLines) return text;
-	return lines.slice(0, maxLines).join("\n");
-}
-function reserveInlineBudgetForSuffix(suffix, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
-	return {
-		maxChars: Math.max(1, maxChars - suffix.length),
-		maxLines: Math.max(1, maxLines - Math.max(0, countSlackLines(suffix) - 1))
-	};
-}
-function forceSplitBudget(text, budget) {
-	const lineCount = countSlackLines(text);
-	return {
-		maxChars: text.length <= budget.maxChars ? Math.max(1, text.length - 1) : budget.maxChars,
-		maxLines: lineCount <= budget.maxLines ? Math.max(1, lineCount - 1) : budget.maxLines
-	};
-}
-function getFenceContinuation(text) {
-	let open;
-	for (const line of text.split("\n")) {
-		const trimmed = line.trimStart();
-		const openerMatch = trimmed.match(/^(`{3,}|~{3,})(.*)$/);
-		if (!openerMatch?.[1]) continue;
-		if (!open) {
-			open = {
-				fence: openerMatch[1],
-				openerLine: trimmed
-			};
-			continue;
-		}
-		if (new RegExp(`^${open.fence}\\s*$`).test(trimmed)) open = void 0;
-	}
-	if (!open) return null;
-	return {
-		closeSuffix: text.endsWith("\n") ? open.fence : `\n${open.fence}`,
-		reopenPrefix: `${open.openerLine}\n`
-	};
-}
-function appendSlackSuffix(text, marker) {
-	return `${text}${getFenceContinuation(text)?.closeSuffix ?? ""}${marker}`;
-}
-function stripTrailingContinuationMarker(text) {
-	return text.endsWith(CONTINUED_MARKER) ? text.slice(0, -19) : text;
-}
-function takeSlackContinuationChunk(text, budget) {
-	let { prefix, rest } = takeSlackInlinePrefix(text, budget);
-	if (!rest) ({prefix, rest} = takeSlackInlinePrefix(text, forceSplitBudget(text, budget)));
-	let carryover = rest ? getFenceContinuation(prefix) : null;
-	if (!carryover) return {
-		prefix,
-		rest
-	};
-	const carryoverBudget = reserveInlineBudgetForSuffix(`${carryover.closeSuffix}${CONTINUED_MARKER}`);
-	({prefix, rest} = takeSlackInlinePrefix(text, carryoverBudget));
-	if (!rest) ({prefix, rest} = takeSlackInlinePrefix(text, forceSplitBudget(text, carryoverBudget)));
-	carryover = rest ? getFenceContinuation(prefix) : null;
-	if (!carryover) return {
-		prefix,
-		rest
-	};
-	return {
-		prefix,
-		rest: `${carryover.reopenPrefix}${rest}`
-	};
-}
-/** Return the first continuation-safe chunk plus any remaining text. */
-function takeSlackContinuationPrefix(text, options) {
-	const budget = {
-		maxChars: options?.maxChars ?? getSlackContinuationBudget().maxChars,
-		maxLines: options?.maxLines ?? getSlackContinuationBudget().maxLines
-	};
-	const { prefix, rest } = (() => {
-		if (options?.forceSplit) return takeSlackContinuationChunk(text, budget);
-		const initial = takeSlackInlinePrefix(text, budget);
-		return initial.rest ? takeSlackContinuationChunk(text, budget) : initial;
-	})();
-	return {
-		prefix,
-		renderedPrefix: rest ? appendSlackSuffix(prefix, CONTINUED_MARKER) : prefix,
-		rest
-	};
-}
-/**
-* Take the largest Slack-safe inline prefix from `text` under the configured
-* character and line budgets. Returns the consumed prefix plus remaining text.
-*/
-function takeSlackInlinePrefix(text, options) {
-	const maxChars = options?.maxChars ?? MAX_INLINE_CHARS;
-	const maxLines = options?.maxLines ?? MAX_INLINE_LINES;
-	const normalized = text.replace(/\r\n?/g, "\n");
-	if (!normalized) return {
-		prefix: "",
-		rest: ""
-	};
-	if (fitsInlineBudget(normalized, maxChars, maxLines)) return {
-		prefix: normalized,
-		rest: ""
-	};
-	const lineBounded = splitByLineBudget(normalized, maxLines);
-	const cutIndex = findSplitIndex(lineBounded, maxChars);
-	const prefix = lineBounded.slice(0, cutIndex).trimEnd();
-	if (prefix) return {
-		prefix,
-		rest: normalized.slice(prefix.length).trimStart()
-	};
-	const hardPrefix = normalized.slice(0, Math.max(1, maxChars)).trimEnd();
-	return {
-		prefix: hardPrefix || normalized.slice(0, Math.max(1, maxChars)),
-		rest: normalized.slice(hardPrefix.length || Math.max(1, maxChars)).trimStart()
-	};
-}
-/**
-* Split a normalized Slack reply into multiple inline-safe thread messages.
-*
-* Replies split across more than two messages receive explicit continuation
-* markers on non-final chunks. When
-* `interrupted` is true, the final chunk receives an interruption marker.
-*/
-function splitSlackReplyText(text, options) {
-	const normalized = normalizeSlackReplyMarkdown(text);
-	if (!normalized) return [];
-	const chunks = [];
-	const continuationBudget = reserveInlineBudgetForSuffix(CONTINUED_MARKER);
-	let remaining = normalized;
-	while (remaining) {
-		if (options?.interrupted ? fitsInlineBudget(appendSlackSuffix(remaining, getInterruptionMarker())) : fitsInlineBudget(remaining)) {
-			chunks.push(options?.interrupted ? appendSlackSuffix(remaining, getInterruptionMarker()) : remaining);
-			break;
-		}
-		const { renderedPrefix, rest } = takeSlackContinuationPrefix(remaining, {
-			...continuationBudget,
-			forceSplit: true
-		});
-		chunks.push(renderedPrefix);
-		remaining = rest;
-	}
-	if (chunks.length === 2) chunks[0] = stripTrailingContinuationMarker(chunks[0] ?? "");
-	return chunks;
-}
-/**
-* Reserve enough inline budget for a continuation suffix on the current chunk.
-*/
-function getSlackContinuationBudget() {
-	return reserveInlineBudgetForSuffix(CONTINUED_MARKER);
-}
-/** Normalize text for Slack and wrap it as a PostableMessage. */
-function buildSlackOutputMessage(text) {
-	const normalized = normalizeSlackReplyMarkdown(text);
-	if (!normalized) throw new Error(`Slack output normalized to empty content: original_length=${text.length} parsed_length=${normalized.length}`);
-	return { markdown: normalized };
-}
-// src/chat/slack/reply.ts
-/**
-* Send one destination-visible Slack reply.
-*
-* Chunks oversized text, builds compact attribution and conversation footer
-* context, and posts through the shared Slack outbound boundary.
-*/
-async function sendSlackReply(args) {
-	const posts = splitSlackReplyText(args.text).map((text) => ({
-		text,
-		cards: []
-	}));
-	const cards = (args.cards ?? []).map((card) => renderSlackCard(card, args.conversationId));
-	for (let index = 0; index < cards.length; index += 5) {
-		const group = cards.slice(index, index + 5);
-		const lastPost = posts.at(-1);
-		if (index === 0 && lastPost) lastPost.cards = group;
-		else posts.push({
-			text: "",
-			cards: group
-		});
-	}
-	const footer = buildSlackReplyFooter({
-		conversationId: args.conversationId,
-		replyAttribution: args.replyAttribution
-	});
-	const messageTs = [];
-	let threadTs = args.threadTs;
-	for (const [index, post] of posts.entries()) {
-		const { text, cards } = post;
-		const isFinalChunk = index === posts.length - 1;
-		const blocks = buildSlackReplyBlocks(text, void 0) ?? [];
-		for (const card of cards) if (!card.entity) blocks.push({
-			type: "section",
-			text: {
-				type: "mrkdwn",
-				text: card.text
-			}
-		});
-		if (isFinalChunk || !text.trim()) blocks.push(...buildSlackReplyBlocks("", footer) ?? []);
-		const entities = cards.flatMap((card) => card.entity ? [card.entity] : []);
-		const accessibleText = [text, ...cards.map((card) => card.text)].filter(Boolean).join("\n\n");
-		const fallbackText = isFinalChunk && args.replyAttribution ? `${accessibleText}\n\n${escapeSlackMrkdwnText(formatReplyAttribution(args.replyAttribution))}` : accessibleText;
-		const response = await postSlackMessage({
-			channelId: args.channelId,
-			threadTs,
-			text: fallbackText,
-			...blocks.length ? { blocks } : void 0,
-			...entities.length ? { entities } : void 0
-		});
-		if (response.ts) {
-			messageTs.push(response.ts);
-			threadTs ??= response.ts;
-		}
-	}
-	return messageTs;
-}
 // src/chat/slack/assistant-thread/status-render.ts
 const DEFAULT_STATUS_CONTEXTS = {
 	thinking: "…",
@@ -4235,6 +3404,21 @@ function formatSlackConversationRedactedLabel(context) {
 	if (!context) return void 0;
 	return formatSlackConversationTypeLabel(context.type);
 }
+// src/chat/slack/avatar.ts
+const AVATAR_SAVE_INTERVAL_MS = 864e5;
+/**
+* Save the Slack photo of one Slack Actor on their Slack Identity. Slack
+* Turns call this, so the saved photo follows profile changes within a day.
+*/
+async function saveSlackActorAvatar(actor) {
+	const state = getStateAdapter();
+	const savedKey = `junior:slack:avatar-saved:${actor.teamId}:${actor.userId}`;
+	if (await state.get(savedKey)) return;
+	const profile = await lookupSlackUser(actor.teamId, actor.userId);
+	if (!profile) return;
+	await saveActorAvatar(getSqlExecutor(), actor, profile.avatarUrl ?? null);
+	await state.set(savedKey, true, AVATAR_SAVE_INTERVAL_MS);
+}
 // src/chat/services/provider-default-config.ts
 const GITHUB_REPO_PART = String.raw`[A-Za-z0-9_.-]*[A-Za-z0-9_-]`;
 const GITHUB_REPO_RE = new RegExp(String.raw`^\s*(?:set|use)\s+(?:the\s+)?default\s+(?:github\s+)?repo(?:sitory)?\s+(?:to|as)\s+(${GITHUB_REPO_PART}/${GITHUB_REPO_PART})(?:\s+for\s+this\s+channel)?[.!?]?\s*$`, "i");
@@ -4379,8 +3563,8 @@ async function saveSteeringMessages(args) {
 * Persist post-delivery Redis scratch with a short retry after durable SQL
 * completion has succeeded.
 */
-async function persistThreadRuntimeStateWithRetry(thread, patch) {
-	await persistWithRetry(() => persistThreadRuntimeState(thread, patch));
+async function persistThreadRuntimeStateWithRetry(conversationId, patch) {
+	await persistWithRetry(() => persistThreadRuntimeState(conversationId, patch));
 }
 /**
 * Resolve the Pi history for this Slack turn from the most precise durable
@@ -4432,6 +3616,10 @@ function createSlackTurn(deps) {
 				visibility: destinationVisibility
 			}) ?? "private"
 		});
+		const replyTarget = resolveSlackReplyTarget({
+			destination,
+			source
+		});
 		const slackActionToken = readSlackActionToken(message);
 		const runId = options.execution?.dispatch?.id ?? getRunId(thread, message);
 		const conversationId = options.conversationId ?? threadId ?? runId;
@@ -4471,8 +3659,10 @@ function createSlackTurn(deps) {
 				executionActor = options.execution.dispatch.actor;
 				credentialContext = options.execution.credentialContext;
 			} else {
-				executionActor = await ensureSlackMessageActorIdentity(message, teamId, lookupSlackUser);
-				if (executionActor) credentialContext = credentialContextForActor(executionActor);
+				const slackActor = await ensureSlackMessageActorIdentity(message, teamId, lookupSlackUser);
+				await saveSlackActorAvatar(slackActor);
+				executionActor = slackActor;
+				credentialContext = credentialContextForActor(slackActor);
 			}
 			if (!executionActor || !credentialContext) throw new Error("Slack reply execution requires an actor");
 			const actor = "userId" in executionActor ? executionActor : void 0;
@@ -4486,6 +3676,7 @@ function createSlackTurn(deps) {
 				destination,
 				locationConfiguration: options.execution?.locationConfiguration,
 				context: {
+					conversationId,
 					threadId,
 					actorId: slackActorId,
 					channelId,
@@ -4503,17 +3694,16 @@ function createSlackTurn(deps) {
 			};
 			const postAuthPauseNotice = async (providerDisplayName, requestText) => {
 				if (!actor) throw new Error("Slack auth pause notice requires an actor");
+				if (!postsRunNotices(options.execution?.dispatch)) return;
 				const text = buildAuthPauseResponse(actor.userId, providerDisplayName, requestText);
 				try {
 					await beforeFirstResponsePost();
-					if (channelId && threadTs) await sendSlackReply({
-						channelId,
+					await sendSlackReply({
+						...replyTarget,
 						conversationId,
 						replyAttribution: options.execution?.dispatch?.replyAttribution,
-						text,
-						threadTs
+						text
 					});
-					else await thread.post(buildSlackOutputMessage(text));
 				} catch (error) {
 					logException(error, "slack.auth_pause.notice_post.failed", {
 						"app.slack.reply_stage": "thread_reply_auth_pause_notice",
@@ -4567,7 +3757,7 @@ function createSlackTurn(deps) {
 				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 });
+				await persistThreadStateById(conversationId, { conversation: preparedState.conversation });
 				await options.onTurnStatePersisted?.();
 				await options.ack?.();
 				await options.onTurnCompleted?.();
@@ -4590,7 +3780,7 @@ function createSlackTurn(deps) {
 						});
 						throw error;
 					}
-					await persistThreadState(thread, { conversation: preparedState.conversation });
+					await persistThreadStateById(conversationId, { conversation: preparedState.conversation });
 					await options.onTurnStatePersisted?.();
 					await options.ack?.();
 					return;
@@ -4628,7 +3818,11 @@ function createSlackTurn(deps) {
 			});
 			if (configReply) {
 				await beforeFirstResponsePost();
-				await thread.post(buildSlackOutputMessage(configReply.text));
+				await sendSlackReply({
+					...replyTarget,
+					conversationId,
+					text: configReply.text
+				});
 				markConversationMessage(preparedState.conversation, preparedState.userMessageId, {
 					replied: true,
 					skippedReason: void 0
@@ -4647,7 +3841,7 @@ function createSlackTurn(deps) {
 						source: "slack"
 					}
 				});
-				await persistThreadState(thread, { conversation: preparedState.conversation });
+				await persistThreadStateById(conversationId, { conversation: preparedState.conversation });
 				await options.onTurnStatePersisted?.();
 				await options.ack?.();
 				return;
@@ -4688,7 +3882,7 @@ function createSlackTurn(deps) {
 				"app.message.id": message.id,
 				...messageTs ? { "messaging.message.id": messageTs } : void 0
 			});
-			await persistThreadState(thread, { conversation: preparedState.conversation });
+			await persistThreadStateById(conversationId, { conversation: preparedState.conversation });
 			await options.onTurnStatePersisted?.();
 			if (actor) setSentryUser({
 				id: actor.userId,
@@ -4775,16 +3969,15 @@ function createSlackTurn(deps) {
 					}
 					else {
 						slackMessageTs = await sendSlackReply({
+							...replyTarget,
 							cards,
-							channelId: destination.channelId,
 							conversationId,
 							replyAttribution: options.execution?.dispatch?.replyAttribution,
-							text,
-							...threadTs ? { threadTs } : void 0
+							text
 						});
 						messageDestinations.push(...slackMessageTs.map((messageId) => ({
 							destination,
-							messageId: threadTs ?? messageId
+							messageId: replyTarget.threadTs ?? messageId
 						})));
 					}
 				} catch (error) {
@@ -4874,7 +4067,7 @@ function createSlackTurn(deps) {
 					});
 					if (compaction.compacted) {
 						piMessages = compaction.piMessages;
-						await persistThreadState(thread, { conversation: preparedState.conversation });
+						await persistThreadStateById(conversationId, { conversation: preparedState.conversation });
 					}
 				}
 				const hasDurablePromptHistory = Boolean(piMessages?.length);
@@ -4983,11 +4176,11 @@ function createSlackTurn(deps) {
 						drainSteeringMessages,
 						shouldYield: options.shouldYield,
 						onSandboxRefChanged: async (sandboxRef) => {
-							await persistThreadState(thread, { sandboxRef });
+							await persistThreadStateById(conversationId, { sandboxRef });
 						},
 						recordPendingAuth: async (pendingAuth) => {
 							preparedState.conversation.processing.pendingAuth = pendingAuth;
-							await persistThreadState(thread, { conversation: preparedState.conversation });
+							await persistThreadStateById(conversationId, { conversation: preparedState.conversation });
 						}
 					}
 				};
@@ -5066,7 +4259,7 @@ function createSlackTurn(deps) {
 							conversation: completedState.conversation,
 							conversationId
 						}));
-						await persistThreadRuntimeStateWithRetry(thread, completedState);
+						await persistThreadRuntimeStateWithRetry(conversationId, completedState);
 						const automatedTurnLimit = await recordFinishedTurnForAutomatedLimit({
 							conversationId,
 							maxTurns: botConfig.maxConsecutiveAutomatedTurns,
@@ -5075,7 +4268,7 @@ function createSlackTurn(deps) {
 						await maybePostAutomatedTurnLimitNotice({
 							conversationId,
 							maxTurns: botConfig.maxConsecutiveAutomatedTurns,
-							threadTs,
+							source,
 							update: automatedTurnLimit
 						});
 					} catch (saveError) {
@@ -5111,7 +4304,7 @@ function createSlackTurn(deps) {
 							nowMs: Date.now(),
 							sessionId: turnId
 						});
-						await persistThreadState(thread, { conversation: preparedState.conversation });
+						await persistThreadStateById(conversationId, { conversation: preparedState.conversation });
 						if (conversationId) await turnLifecycle.fail({
 							conversationId,
 							createdAtMs: Date.now(),
@@ -5128,7 +4321,7 @@ function createSlackTurn(deps) {
 						conversation: preparedState.conversation,
 						sessionId: turnId
 					});
-					await persistThreadState(thread, { conversation: preparedState.conversation });
+					await persistThreadStateById(conversationId, { conversation: preparedState.conversation });
 					persistedAtLeastOnce = true;
 					shouldPersistFailureState = false;
 					return;
@@ -5212,7 +4405,7 @@ function createSlackTurn(deps) {
 						nowMs: Date.now(),
 						sessionId: turnId
 					});
-					await persistThreadState(thread, { conversation: preparedState.conversation });
+					await persistThreadStateById(conversationId, { conversation: preparedState.conversation });
 					await turnLifecycle.complete({
 						conversationId,
 						createdAtMs: Date.now(),
@@ -5269,7 +4462,7 @@ function createSlackTurn(deps) {
 					} catch (recordError) {
 						logException(recordError, "agent.turn.failed_session_record_persist.failed");
 					}
-					await persistThreadState(thread, { conversation: preparedState.conversation });
+					await persistThreadStateById(conversationId, { conversation: preparedState.conversation });
 					if (shouldEmitDevAgentTrace()) logWarn("agent.turn.failed");
 				}
 				await status.clear();
@@ -5408,10 +4601,10 @@ async function seedConversationBackfill(thread, conversation, currentTurn, resol
 /** Build the turn-state preparer from injected conversation services. */
 function createPrepareTurnState(deps) {
 	return async function prepareTurnState(args) {
-		const existingState = await args.thread.state;
+		const conversationId = args.context.conversationId ?? args.context.threadId ?? args.context.runId;
+		const existingState = conversationId ? await getPersistedThreadState(conversationId) : await args.thread.state;
 		const sandboxRef = getPersistedSandboxState(existingState ?? {});
 		const conversation = coerceThreadConversationState(existingState);
-		const conversationId = args.context.threadId ?? args.context.runId;
 		if (conversationId && isVisionEnabled()) conversation.vision = await loadConversationVisionCache(conversationId);
 		await hydrateConversationMessages({
 			conversation,
@@ -5596,8 +4789,8 @@ function createSlackRuntime(options) {
 			modelId: defaultModelId(botConfig),
 			now: options.now ?? (() => Date.now()),
 			prepareTurnState,
-			persistPreparedState: async ({ thread, preparedState }) => {
-				await persistThreadState(thread, { conversation: preparedState.conversation });
+			persistPreparedState: async ({ conversationId, preparedState }) => {
+				await persistThreadStateById(conversationId, { conversation: preparedState.conversation });
 			},
 			getPreparedConversationContext: (preparedState) => preparedState.conversationContext,
 			decideSubscribedReply: async (args) => {
@@ -5612,18 +4805,18 @@ function createSlackRuntime(options) {
 				});
 				return decision;
 			},
-			recordSkippedSteeringMessage: async ({ thread, message, decision, text }) => {
-				const conversation = coerceThreadConversationState(await thread.state);
+			recordSkippedSteeringMessage: async ({ conversationId, message, decision, text }) => {
+				const conversation = coerceThreadConversationState(await getPersistedThreadState(conversationId));
 				recordSkippedConversationMessage({
 					conversation,
 					message,
 					skippedReason: decision.reason,
 					text: text.userText
 				});
-				await persistThreadState(thread, { conversation });
+				await persistThreadStateById(conversationId, { conversation });
 			},
-			recordSkippedSubscribedTurn: async ({ thread, message, decision, completedAtMs, text }) => {
-				const conversation = coerceThreadConversationState(await thread.state);
+			recordSkippedSubscribedTurn: async ({ conversationId, message, decision, completedAtMs, text }) => {
+				const conversation = coerceThreadConversationState(await getPersistedThreadState(conversationId));
 				recordSkippedConversationMessage({
 					conversation,
 					message,
@@ -5632,16 +4825,16 @@ function createSlackRuntime(options) {
 				});
 				clearSkippedTurnIfActive(conversation, message.id);
 				conversation.processing.lastCompletedAtMs = completedAtMs;
-				await persistThreadState(thread, { conversation });
+				await persistThreadStateById(conversationId, { conversation });
 			},
-			onSubscribedMessageSkipped: async ({ thread, message, preparedState, decision, completedAtMs }) => {
+			onSubscribedMessageSkipped: async ({ conversationId, message, preparedState, decision, completedAtMs }) => {
 				markConversationMessage(preparedState.conversation, preparedState.userMessageId, {
 					replied: false,
 					skippedReason: decision.reason
 				});
 				clearSkippedTurnIfActive(preparedState.conversation, message.id);
 				preparedState.conversation.processing.lastCompletedAtMs = completedAtMs;
-				await persistThreadState(thread, { conversation: preparedState.conversation });
+				await persistThreadStateById(conversationId, { conversation: preparedState.conversation });
 			},
 			executeSlackTurn,
 			initializeAssistantThread: async ({ channelId, threadTs, sourceChannelId }) => {
@@ -5688,23 +4881,20 @@ function createJuniorSlackAdapter(config) {
 * authorization pause notices use `sendSlackReply` so the footer stays
 * consistent.
 */
-async function postSlackMessageBestEffort(channelId, threadTs, text, conversationId, replyAttribution) {
+/** Post a failure reply or status notice when the run's dispatch allows it. */
+async function postRunNotice(resume, text) {
+	if (!postsRunNotices(resume.run?.dispatch)) return;
+	await sendSlackReply({
+		channelId: resume.channelId,
+		conversationId: resume.conversationId,
+		replyAttribution: resume.run?.dispatch?.replyAttribution,
+		text,
+		threadTs: resume.threadTs
+	});
+}
+async function postRunNoticeBestEffort(resume, text) {
 	try {
-		if (conversationId) {
-			await sendSlackReply({
-				channelId,
-				conversationId,
-				replyAttribution,
-				text,
-				threadTs
-			});
-			return;
-		}
-		await postSlackMessage({
-			channelId,
-			threadTs,
-			text
-		});
+		await postRunNotice(resume, text);
 	} catch {}
 }
 /** Create a read-only configuration service from persisted values. */
@@ -5745,13 +4935,6 @@ function getResumeLogContext(args) {
 		modelId: defaultModelId(botConfig)
 	};
 }
-async function postResumeFailureReply(args) {
-	await postSlackMessage({
-		channelId: args.channelId,
-		threadTs: args.threadTs,
-		text: buildTurnErrorResponse(args.error, args.eventId)
-	});
-}
 async function handleResumeFailure(args) {
 	const turnLifecycle = getTurnLifecycle();
 	const capturedEventId = logException(args.error, args.eventName);
@@ -5775,12 +4958,7 @@ async function handleResumeFailure(args) {
 		failureStatePersistError = persistError;
 	}
 	try {
-		await postResumeFailureReply({
-			channelId: args.resume.channelId,
-			threadTs: args.resume.threadTs,
-			eventId,
-			error: args.error
-		});
+		await postRunNotice(args.resume, buildTurnErrorResponse(args.error, eventId));
 	} catch (deliveryError) {
 		const deliveryEventId = logException(deliveryError, "slack.resume.failure_delivery.failed", { "app.error.original_event_id": eventId });
 		try {
@@ -5899,7 +5077,7 @@ async function resumeSlackTurnInContext(args) {
 			channelId: runArgs.channelId,
 			timestamp: runArgs.messageTs
 		});
-		if (runArgs.initialText) await postSlackMessageBestEffort(runArgs.channelId, runArgs.threadTs, runArgs.initialText);
+		if (runArgs.initialText) await postRunNoticeBestEffort(runArgs, runArgs.initialText);
 		status.update(runArgs.initialStatus);
 		const conversationId = runArgs.conversationId;
 		const visibleConversationId = args.conversationId;
@@ -6154,7 +5332,7 @@ async function resumeSlackTurnInContext(args) {
 	}
 	if (deferredPauseHandler) try {
 		await deferredPauseHandler();
-		if (deferredAuthInfo) await postSlackMessageBestEffort(runArgs.channelId, runArgs.threadTs, buildAuthPauseResponse(deferredAuthInfo.actorId, deferredAuthInfo.providerDisplayName, deferredAuthInfo.requestText), runArgs.conversationId, runArgs.run?.dispatch?.replyAttribution);
+		if (deferredAuthInfo) await postRunNoticeBestEffort(runArgs, buildAuthPauseResponse(deferredAuthInfo.actorId, deferredAuthInfo.providerDisplayName, deferredAuthInfo.requestText));
 		return true;
 	} catch (pauseError) {
 		await handleResumeFailure({
@@ -6347,16 +5525,22 @@ async function runPausedTurn(payload, options, runOptions = {}) {
 	return withLogContext({ conversationId: payload.conversationId }, () => runPausedTurnInContext(payload, options, runOptions));
 }
 async function runPausedTurnInContext(payload, options, runOptions) {
-	const thread = parseSlackThreadId(payload.conversationId);
 	const destination = requireSlackDestination(payload.destination, "Paused turn");
 	const wakePausedTurn$1 = options.wakePausedTurn ?? wakePausedTurn;
+	const routing = await resolveConversationRouting({ conversationId: payload.conversationId });
+	const pausedTurn = await getTurnRecord(payload.conversationId, payload.turnId);
+	const target = resolveSlackReplyTarget({
+		destination,
+		location: routing?.location,
+		source: pausedTurn?.source
+	});
 	return await resumeSlackTurn({
 		messageText: "",
 		conversationId: payload.conversationId,
 		turnId: payload.turnId,
 		traceContext: payload.traceContext,
-		channelId: thread?.channelId ?? destination.channelId,
-		...thread?.threadTs ? { threadTs: thread.threadTs } : void 0,
+		channelId: target.channelId,
+		...target.threadTs ? { threadTs: target.threadTs } : void 0,
 		executeTurn: async (run, saveResult) => await executeTurn(options.agentRunner, run, saveResult),
 		scheduleSessionCompletedPluginTasks: options.scheduleSessionCompletedPluginTasks,
 		beforeStart: async () => {
@@ -6569,6 +5753,23 @@ async function failStrandedTurnWithFallback(args) {
 		failureCode: "agent_run_failed",
 		turnId: failed.turnId
 	});
+	let replyAttribution;
+	if (failed.dispatchId) {
+		const dispatch = await getDispatchRecord(failed.dispatchId);
+		await recordTurnSummary({
+			conversationId: args.conversationId,
+			destination: dispatch?.destination,
+			dispatchId: failed.dispatchId,
+			dispatchOutcome: "failed",
+			turnId: failed.turnId,
+			sliceId: failed.sliceId,
+			source: dispatch?.source,
+			state: "failed",
+			surface: failed.surface
+		});
+		if (!dispatch || !postsRunNotices(buildDispatchRoutingContext(dispatch).dispatch)) return true;
+		replyAttribution = dispatch.replyAttribution;
+	}
 	let routing;
 	try {
 		routing = await resolveTurnSessionRouting({ conversationId: args.conversationId });
@@ -6579,22 +5780,15 @@ async function failStrandedTurnWithFallback(args) {
 		});
 		return true;
 	}
-	if (failed.dispatchId) await recordTurnSummary({
-		conversationId: args.conversationId,
-		destination: routing.destination,
-		dispatchId: failed.dispatchId,
-		dispatchOutcome: "failed",
-		turnId: failed.turnId,
-		sliceId: failed.sliceId,
-		source: routing.source,
-		state: "failed",
-		surface: failed.surface
+	const target = resolveSlackReplyTarget({
+		destination: requireSlackDestination(routing.destination, "Stranded paused turn"),
+		location: routing.location,
+		source: failed.source
 	});
-	const thread = parseSlackThreadId(args.conversationId);
-	const channelId = thread?.channelId ?? requireSlackDestination(routing.destination, "Stranded paused turn").channelId;
-	await postSlackMessage({
-		channelId,
-		...thread?.threadTs ? { threadTs: thread.threadTs } : void 0,
+	await sendSlackReply({
+		...target,
+		conversationId: args.conversationId,
+		replyAttribution,
 		text: buildTurnFailureResponse(requireTurnFailureEventId(eventId, eventName))
 	});
 	return true;
@@ -6775,6 +5969,7 @@ function createWebSteeringDrain(args) {
 					text: normalizeConversationText(message.input.text),
 					createdAtMs: message.createdAtMs,
 					author,
+					...message.input.authorIdentityId ? { authorIdentityId: message.input.authorIdentityId } : void 0,
 					meta: {
 						...attachments.length ? { attachments } : void 0,
 						explicitMention: true,
@@ -6797,28 +5992,9 @@ function createWebSteeringDrain(args) {
 		return accepted;
 	};
 }
-// src/chat/conversations/destination.ts
-function requireLocalDestination(conversationId) {
-	const parsed = localDestinationSchema.safeParse({
-		platform: "local",
-		conversationId
-	});
-	if (!parsed.success) throw new Error(`Invalid local conversation id: ${conversationId}`);
-	return parsed.data;
-}
-/**
-* Keep a stored Destination, or create the temporary local Destination.
-*
-* TODO(dcramer): Delete this module after Conversation and AgentRun use
-* Location, and web and event Turns no longer need a local
-* Destination.
-*/
-function resolveConversationDestination(args) {
-	return args.existing ?? requireLocalDestination(args.conversationId);
-}
 // src/chat/task-execution/conversation-turn.ts
 /** Run a mailbox Turn and store its assistant Messages. */
-function stableHex$1(...parts) {
+function stableHex(...parts) {
 	return createHash("sha256").update(parts.join("\0")).digest("hex").slice(0, 24);
 }
 function captureConversationTurnFailure(args) {
@@ -6876,6 +6052,14 @@ async function completeCancelledConversationTurn(args) {
 	await args.acknowledge();
 }
 /**
+* Return the author Identity id that every batched input shares.
+* A batch with more than one author has no single author yet.
+*/
+function sharedAuthorIdentityId(messages) {
+	const ids = new Set(messages.map((message) => message.input.authorIdentityId));
+	return ids.size === 1 ? [...ids][0] : void 0;
+}
+/**
 * Create the shared mailbox worker for web and event Turns.
 */
 function createConversationTurnWorker(agentRunner, deliverMessage) {
@@ -6898,6 +6082,7 @@ function createConversationTurnWorker(agentRunner, deliverMessage) {
 		let inputMessageIds = [];
 		let event;
 		let batchEvents = [];
+		let authorIdentityId;
 		const storedConversation = await getConversationStore().get({ conversationId: context.conversationId });
 		const mailboxDestination = resolved.kind === "mailbox" ? resolved.batch[0]?.message.destination : void 0;
 		const destination = resolveConversationDestination({
@@ -6918,6 +6103,7 @@ function createConversationTurnWorker(agentRunner, deliverMessage) {
 			userMessageId = first.message.inboundMessageId;
 			turnId = buildDeterministicTurnId(userMessageId);
 			inputMessageIds = resolved.batch.map((entry) => entry.message.inboundMessageId);
+			authorIdentityId = sharedAuthorIdentityId(messages);
 			turnInputFacts = first;
 		} else turnId = resolved.turnId;
 		const persisted = await getPersistedThreadState(context.conversationId);
@@ -7004,6 +6190,7 @@ function createConversationTurnWorker(agentRunner, deliverMessage) {
 					text: normalizeConversationText(text),
 					createdAtMs: startedAtMs,
 					author,
+					...authorIdentityId ? { authorIdentityId } : void 0,
 					meta: {
 						...attachments.length ? { attachments } : void 0,
 						explicitMention: true,
@@ -7097,7 +6284,7 @@ function createConversationTurnWorker(agentRunner, deliverMessage) {
 				if (stopSignal?.aborted) return await completeCancelledTurn();
 				const piMessages = await loadProjection({ conversationId: context.conversationId });
 				failureCode = "agent_run_failed";
-				currentRunId = `conversation-run:${stableHex$1(turnId, String(startedAtMs))}`;
+				currentRunId = `conversation-run:${stableHex(turnId, String(startedAtMs))}`;
 				setTags({ runId: currentRunId });
 				const outcome = await executeTurn(agentRunner, {
 					conversationId: context.conversationId,
@@ -7195,7 +6382,7 @@ function createConversationTurnWorker(agentRunner, deliverMessage) {
 					await maybePostAutomatedTurnLimitNotice({
 						conversationId: context.conversationId,
 						maxTurns: botConfig.maxConsecutiveAutomatedTurns,
-						threadTs: conversationLocation?.provider === "slack" ? conversationLocation.threadTs : void 0,
+						source,
 						update: automatedTurnLimit
 					});
 					completedSuccessfully = reply.diagnostics.outcome === "success";
@@ -7307,11 +6494,13 @@ function createSlackSystemTurnDelivery(args) {
 				installation: { teamId: location.teamId },
 				state: args.state,
 				task: async () => await sendSlackReply({
+					...resolveSlackReplyTarget({
+						destination: location,
+						location
+					}),
 					cards,
-					channelId: location.channelId,
 					conversationId,
-					text,
-					...location.threadTs ? { threadTs: location.threadTs } : void 0
+					text
 				})
 			});
 		} catch (error) {
@@ -7376,12 +6565,14 @@ function createConversationWork(options) {
 		},
 		runTurn: runtime.runDispatchTurn
 	});
-	const invocationWorker = createAgentInvocationWorker(options.agentRunner, {
+	const childWorker = createChildConversationWorker(options.agentRunner, {
 		enqueueResult: async (invocation) => await enqueueAgentInvocationResult(invocation, {
 			queue: options.queue,
 			state: options.state
 		}),
-		maxAgentDepth: botConfig.maxAgentDepth
+		maxAgentDepth: botConfig.maxAgentDepth,
+		queue: options.queue,
+		state: options.state
 	});
 	const conversationTurnWorker = createConversationTurnWorker(options.agentRunner, createSlackSystemTurnDelivery({
 		getSlackAdapter: options.getSlackAdapter,
@@ -7396,15 +6587,9 @@ function createConversationWork(options) {
 	const run = async (context) => {
 		const skipped = await skipInputBeforeConversationStop(context);
 		if (skipped) return skipped;
-		const childInput = await startAgentInvocationsForChildInput(context, {
-			queue: options.queue,
-			state: options.state
-		});
-		if (childInput) return childInput;
+		if ((await options.conversationStore.get({ conversationId: context.conversationId }))?.parentConversationId) return await childWorker(context);
 		const mailboxTurn = await resolveMailboxTurnWork(context);
 		if (mailboxTurn) return await conversationTurnWorker(context, await withAgentInvocationResultActors(mailboxTurn));
-		const invocationId = await resolveAgentInvocationId(context);
-		if (invocationId) return await invocationWorker(context, invocationId);
 		const dispatchId = await resolveAgentDispatchId(context);
 		if (dispatchId) return await dispatchWorker(context, dispatchId);
 		return await destinationWorker(context);
@@ -7471,167 +6656,6 @@ function createProductionConversationWorkOptions(options) {
 		waitUntil: options.waitUntil
 	});
 }
-// src/chat/conversations/web-input.ts
-function normalizeEmail(email) {
-	return email.trim().toLowerCase();
-}
-function stableHex(...parts) {
-	return createHash("sha256").update(parts.join("\0")).digest("hex").slice(0, 24);
-}
-/**
-* Build a durable Conversation id for one web Actor and create key.
-*
-* Retries with the same key must address the same Conversation before the
-* mailbox Message id is derived.
-*/
-function createConversationId(args) {
-	return `local:web:${stableHex(normalizeEmail(args.actorEmail), args.idempotencyKey)}`;
-}
-/** Return the stable Turn id for one mailbox Message. */
-function conversationTurnIdForMessage(messageId) {
-	return buildDeterministicTurnId(messageId);
-}
-/**
-* Store the dashboard participant in the current Conversation actor field.
-*
-* TODO(dcramer): Remove this StoredSlackActor conversion after Conversation
-* actor storage accepts web Actors directly.
-*/
-function storedActorFromWeb(actor) {
-	return {
-		...actor.email ? { email: normalizeEmail(actor.email) } : void 0,
-		...actor.fullName ? { fullName: actor.fullName } : void 0
-	};
-}
-/** Rebuild the web Actor from durable Conversation identity. */
-function webActorFromEmail(email, profile) {
-	const normalized = normalizeEmail(email);
-	return {
-		platform: "web",
-		userId: `dashboard:${stableHex(normalized)}`,
-		email: normalized,
-		...profile?.fullName ? { fullName: profile.fullName } : void 0,
-		...profile?.userName ? { userName: profile.userName } : void 0
-	};
-}
-/** Build one web mailbox entry. */
-function buildWebInboundMessage(args) {
-	const text = args.message.trim();
-	if (!text && !args.attachments?.length) throw new Error("Web Message must not be empty");
-	if (!args.actor.email) throw new Error("Web Actor requires a verified email");
-	const destination = resolveConversationDestination({
-		conversationId: args.conversationId,
-		existing: args.destination
-	});
-	const nowMs = args.nowMs ?? Date.now();
-	return {
-		conversationId: args.conversationId,
-		createdAtMs: args.createdAtMs ?? nowMs,
-		delivery: "defer",
-		destination,
-		inboundMessageId: args.messageId,
-		input: {
-			authorId: args.actor.userId,
-			text,
-			...args.attachments?.length ? { attachments: args.attachments } : void 0,
-			metadata: {
-				authorEmail: normalizeEmail(args.actor.email),
-				...args.actor.fullName && { authorFullName: args.actor.fullName },
-				authorUserId: args.actor.userId,
-				...args.actor.userName && { authorUserName: args.actor.userName },
-				kind: "api_turn",
-				messageId: args.messageId
-			}
-		},
-		receivedAtMs: nowMs,
-		source: "web"
-	};
-}
-/** Record web activity and create a Conversation root when needed. */
-async function recordWebConversationActivity(args) {
-	const store = args.conversationStore ?? getConversationStore();
-	const existing = await store.get({ conversationId: args.conversationId });
-	const destination = resolveConversationDestination({
-		conversationId: args.conversationId,
-		existing: existing?.destination
-	});
-	const isNewRoot = !existing;
-	const visibility = args.rootVisibility === "private" ? "private" : "public";
-	const source = isNewRoot ? createWebSource(args.conversationId, visibility) : void 0;
-	await store.recordActivity({
-		conversationId: args.conversationId,
-		destination,
-		nowMs: args.nowMs,
-		actor: storedActorFromWeb(args.actor),
-		...isNewRoot ? { source: "web" } : void 0,
-		...source ? { sessionSource: source } : void 0,
-		...isNewRoot ? { visibility } : void 0
-	});
-	return destination;
-}
-/** Create a Conversation from web input and enqueue its first Message. */
-async function createAndEnqueueConversation(input, options) {
-	if (!input.actor.email) throw new Error("Web Actor requires a verified email");
-	const conversationId = createConversationId({
-		actorEmail: input.actor.email,
-		idempotencyKey: input.idempotencyKey
-	});
-	return await appendAndEnqueueWebMessage({
-		actor: input.actor,
-		conversationId,
-		idempotencyKey: input.idempotencyKey,
-		message: input.message,
-		images: input.images,
-		rootVisibility: input.visibility === "private" ? "private" : "public"
-	}, options);
-}
-async function appendAndEnqueueWebMessage(input, options) {
-	const text = input.message.trim();
-	if (!text && !input.images?.length) throw new Error("Web Message must not be empty");
-	if (!input.actor.email) throw new Error("Web Actor requires a verified email");
-	const nowMs = options.nowMs ?? Date.now();
-	const messageId = await webMessageId({
-		conversationId: input.conversationId,
-		idempotencyKey: input.idempotencyKey
-	});
-	const destination = await recordWebConversationActivity({
-		actor: input.actor,
-		conversationId: input.conversationId,
-		conversationStore: options.conversationStore,
-		nowMs,
-		...input.rootVisibility && { rootVisibility: input.rootVisibility }
-	});
-	let attachments = [];
-	if (input.images?.length) {
-		if (!options.attachmentStorage) throw new Error("Attachment storage is unavailable.");
-		attachments = await storeInputImages({
-			conversationId: input.conversationId,
-			files: input.images,
-			storage: options.attachmentStorage
-		});
-	}
-	const result = await (options.exclusive ? appendAndEnqueueExclusiveInboundMessage : appendAndEnqueueInboundMessage)({
-		message: buildWebInboundMessage({
-			actor: input.actor,
-			conversationId: input.conversationId,
-			destination,
-			message: text,
-			attachments,
-			messageId,
-			nowMs
-		}),
-		conversationStore: options.conversationStore,
-		nowMs,
-		queue: options.queue,
-		state: options.state
-	});
-	const status = result.status === "appended" ? "accepted" : result.status;
-	return {
-		conversationId: input.conversationId,
-		messageId,
-		status
-	};
-}
 // src/chat/slack/location-url.ts
 /** Parse a Slack workspace subdomain used in `https://{domain}.slack.com` URLs. */
 function parseSlackTeamDomain(value) {
@@ -8343,7 +7367,7 @@ async function readLastUserMessageAtByConversation(db, conversationIds) {
 	const rows = await db.select({
 		conversationId: juniorConversationEvents.conversationId,
 		lastUserMessageAt: sql`max(${juniorConversationEvents.createdAt})`
-	}).from(juniorConversationEvents).where(and(inArray(juniorConversationEvents.conversationId, conversationIds), or(and(eq(juniorConversationEvents.type, "user_message"), eq(authority, "instruction"), sql`${actorPlatform} in ('slack', 'local', 'web')`), and(eq(juniorConversationEvents.type, "message"), eq(role, "user"), isNotNull(juniorConversationEvents.actorIdentityId))))).groupBy(juniorConversationEvents.conversationId);
+	}).from(juniorConversationEvents).leftJoin(juniorIdentities, eq(juniorIdentities.id, juniorConversationEvents.actorIdentityId)).where(and(inArray(juniorConversationEvents.conversationId, conversationIds), or(and(eq(juniorConversationEvents.type, "user_message"), eq(authority, "instruction"), sql`${actorPlatform} in ('slack', 'local', 'web')`), and(eq(juniorConversationEvents.type, "message"), eq(role, "user"), eq(juniorIdentities.kind, "user"))))).groupBy(juniorConversationEvents.conversationId);
 	return new Map(rows.map((row) => [row.conversationId, new Date(row.lastUserMessageAt).toISOString()]));
 }
 // src/api/conversations/activity-preview.ts
@@ -8519,6 +7543,7 @@ async function attachActivityPreviewMentions(executor, previews) {
 }
 // src/api/conversations/participants.ts
 const identityColumns = {
+	avatarUrl: juniorIdentities.avatarUrl,
 	displayName: juniorIdentities.displayName,
 	email: juniorIdentities.email,
 	handle: juniorIdentities.handle,
@@ -8529,11 +7554,13 @@ const identityColumns = {
 	userEmail: juniorUsers.primaryEmail,
 	userId: juniorIdentities.userId
 };
-function participantIdentity(row) {
+function participantIdentity(row, userAvatarUrls) {
+	const avatarUrl = identityAvatarUrl(row, userAvatarUrls);
 	const fullName = row.userDisplayName?.trim() || row.displayName?.trim();
 	const email = row.email?.trim() || row.userEmail?.trim();
 	const slack = row.provider === "slack";
 	const participant = {
+		...avatarUrl ? { avatarUrl } : void 0,
 		...email ? { email } : void 0,
 		...fullName ? { fullName } : void 0,
 		...slack && row.providerSubjectId ? { slackUserId: row.providerSubjectId } : void 0,
@@ -8551,10 +7578,11 @@ async function readConversationParticipants(db, conversationIds) {
 		conversationId: juniorConversationEvents.conversationId,
 		seq: juniorConversationEvents.seq,
 		...identityColumns
-	}).from(juniorConversationEvents).innerJoin(juniorIdentities, eq(juniorIdentities.id, juniorConversationEvents.actorIdentityId)).leftJoin(juniorUsers, eq(juniorUsers.id, juniorIdentities.userId)).where(inArray(juniorConversationEvents.conversationId, [...conversationIds])).orderBy(asc(juniorConversationEvents.conversationId), asc(juniorConversationEvents.actorIdentityId), asc(juniorConversationEvents.seq))]);
+	}).from(juniorConversationEvents).innerJoin(juniorIdentities, eq(juniorIdentities.id, juniorConversationEvents.actorIdentityId)).leftJoin(juniorUsers, eq(juniorUsers.id, juniorIdentities.userId)).where(and(inArray(juniorConversationEvents.conversationId, [...conversationIds]), ne(juniorIdentities.kind, "system"))).orderBy(asc(juniorConversationEvents.conversationId), asc(juniorConversationEvents.actorIdentityId), asc(juniorConversationEvents.seq))]);
+	const userAvatarUrls = await readUserAvatarUrls(db, [...rootRows, ...eventRows].flatMap((row) => row.userId ? [row.userId] : []));
 	const ordered = /* @__PURE__ */ new Map();
 	const add = (conversationId, row) => {
-		const participant = participantIdentity(row);
+		const participant = participantIdentity(row, userAvatarUrls);
 		if (!participant) return;
 		const group = ordered.get(conversationId) ?? {
 			identities: [],
@@ -8784,4 +7812,4 @@ async function readConversationFeedFromSql(options = {}) {
 async function readConversationFeed(options = {}) {
 	return conversationFeedSchema.parse(await readConversationFeedFromSql(options));
 }
-export { renderSlackObjectCard as $, readViewerAutomationRuns as A, recordSkippedConversationMessage as B, createProductionSlackWebhookServices as C, deleteViewerTask as D, ViewerTaskNotFoundError as E, assertNoLegacyAllowedDomains as F, normalizeIncomingSlackThreadId as G, clearSlackPendingReactions as H, isAllowedDomain as I, THREAD_OPTOUT_ACK as J, withNormalizedThreadId as K, isAllowedSignInEmail as L, readViewerAutomationVersions as M, readViewerAutomations as N, readConversationSourceTask as O, resolveViewerTaskCandidate as P, verifySlackSignature as Q, readEnvList as R, createProductionConversationWorkOptions as S, createSlackWebApiStatusSender as T, isSlackMessageStopped as U, buildSlackInboundMessage as V, stopSlackThread as W, parseContent as X, startProcessingReaction as Y, runWithSlackInstallation as Z, appendAndEnqueueWebMessage as _, resolveMentions as a, recordWebConversationActivity as b, readConversationAuxiliaryCostsFromSql as c, notCopiedByFork as d, getAttachmentStorage as et, childAgentTotalsReport as f, resolveSlackTeamDomains as g, conversationSummaryFromStoredConversation as h, attachConversationMentions as i, readHealthReport as it, readViewerAutomationSummary as j, readViewerAutomationExecutions as k, ConversationForkError as l, conversationEventHistory as m, readConversationRecordFromSql as n, enqueueAgentDispatch as nt, readFirstHumanMessageTexts as o, readConversationTreeMetricsFromSql as p, stopConversationTurn as q, readConversationParticipants as r, GET as rt, listConversationSidebarAnnotations as s, readConversationFeed as t, AGENT_DISPATCH_MAX_AGE_MS as tt, forkConversation as u, conversationTurnIdForMessage as v, getProductionSlackAdapter as w, webActorFromEmail as x, createAndEnqueueConversation as y, resolveAllowedDomains as z };
+export { stopSlackThread as A, actOnReviewItem as B, isAllowedSignInEmail as C, buildSlackInboundMessage as D, recordSkippedConversationMessage as E, bindMessageAuthorIdentityId as F, AGENT_DISPATCH_MAX_AGE_MS as G, readReviewItemForUser as H, startProcessingReaction as I, readHealthReport as J, enqueueAgentDispatch as K, stripLeadingBotMention as L, withNormalizedThreadId as M, stopConversationTurn as N, clearSlackPendingReactions as O, THREAD_OPTOUT_ACK as P, parseContent as R, isAllowedDomain as S, resolveAllowedDomains as T, reviewItemChange as U, closeReviewItemsAnsweredByReply as V, getAttachmentStorage as W, createProductionConversationWorkOptions as _, resolveMentions as a, createSlackWebApiStatusSender as b, readConversationAuxiliaryCostsFromSql as c, notCopiedByFork as d, childAgentTotalsReport as f, resolveSlackTeamDomains as g, conversationSummaryFromStoredConversation as h, attachConversationMentions as i, normalizeIncomingSlackThreadId as j, isSlackMessageStopped as k, ConversationForkError as l, conversationEventHistory as m, readConversationRecordFromSql as n, readFirstHumanMessageTexts as o, readConversationTreeMetricsFromSql as p, GET as q, readConversationParticipants as r, listConversationSidebarAnnotations as s, readConversationFeed as t, forkConversation as u, createProductionSlackWebhookServices as v, readEnvList as w, assertNoLegacyAllowedDomains as x, getProductionSlackAdapter as y, ReviewItemActionError as z };