@sentry/junior 0.266.0 → 0.268.0

package/dist/{web-input-B-bMjD1V.js → list-BkgnXEEB.js}

@@ -1,41 +1,42 @@
-import { $ as persistConversationMessageSummaries, A as commitAcceptedReply, At as abandonTurnRecord, Bt as buildTurnErrorResponse, E as sameDefinitionValue, Et as wasPendingAuthStopped, F as loadProjection, Ft as recordTurnSummary, H as recordAuthorizationCompleted, K as recordSubscribedReplyRoute, Mt as failTurnRecord, N as loadConversationProjection, Nt as getTurnRecord, Ot as loadTurnCheckpoint, Pt as listTurnSummaries, S as automationDefinition, Ut as persistWithRetry, X as hydrateConversationMessages, Z as persistConversationMessages, _ as parseEventAutomationRow, _n as isExperimentalFeatureEnabled, at as buildConversationContext, bn as configValueSchema, bt as AuthorizationFlowDisabledError, c as withScheduledAutomationLock, cn as buildDeterministicTurnId, ct as getConversationMessageSlackTs, dn as getSubscribedReplyPreflightDecision, dt as normalizeConversationText, et as resolveConversationTitle, f as deleteEventAutomation, fn as getThreadStopDecision, ft as recordDeliveredAssistantMessage, gt as PluginCredentialFailureError, h as listDeletedEventAutomationsCreatedBy, i as readScheduledAutomation, it as appendThreadContextMessages, j as commitMessages, jt as completeTurnRecord, kt as saveTurnCheckpoint, lt as isHumanConversationMessage, mt as upsertConversationMessage, nt as fallbackShortTitle, o as saveScheduledAutomationInLock, ot as createConversationMemoryService, pt as turnHasReply, r as parseScheduledAutomationRow, rn as trimTrailingAssistantMessages, sn as buildDeterministicAssistantMessageId, st as estimateConversationContextTokens, un as decideSubscribedThreadReply, ut as markConversationMessage, w as listAutomationVersions, wt as clearPendingAuth } from "./tasks-DDT-J3Rf.js";
-import { a as completeText, p as escapeXml, r as completeDecision, y as isProviderRetryError } from "./client-B0YZfxNy.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-C0UwYqDK.js";
-import { B as toOptionalNumber, T as withSpan, V as toOptionalString, d as logError, f as logException, m as logWarn, n as createChatSdkLogger, o as getActiveTraceId, p as logInfo, t as buildTurnFailureResponse, v as setSentryUser, w as withLogContext, x as setTags, y as setSpanAttributes, z as isRecord } from "./logging-Ce0mXZ8J.js";
+import { A as resolveConversationRouting, At as upsertConversationMessage, Bt as clearPendingAuth, Ct as estimateConversationContextTokens, Dt as normalizeConversationText, E as sameDefinitionValue, Et as markConversationMessage, Gt as saveTurnCheckpoint, Ht as wasPendingAuthStopped, In as persistWithRetry, It as AuthorizationFlowDisabledError, Jt as failTurnRecord, K as commitAcceptedReply, Kt as abandonTurnRecord, Mt as PluginCredentialFailureError, N as automationEventCatalog, Nn as buildTurnErrorResponse, Ot as recordDeliveredAssistantMessage, Q as loadTurnProjection, S as automationDefinition, St as createConversationMemoryService, Tt as isHumanConversationMessage, V as registeredEventTriggerProblems, Wt as loadTurnCheckpoint, Xn as trimTrailingAssistantMessages, Xt as listTurnSummaries, Y as loadConversationProjection, Yt as getTurnRecord, Z as loadProjection, Zt as recordTurnSummary, _ as parseEventAutomationRow, ar as getThreadStopDecision, bt as appendThreadContextMessages, c as withScheduledAutomationLock, ct as recordSubscribedReplyRoute, er as buildDeterministicAssistantMessageId, f as deleteEventAutomation, ft as hydrateConversationMessages, gt as resolveConversationTitle, h as listDeletedEventAutomationsCreatedBy, hr as piMessageFromHistoryItem, ht as persistConversationMessageSummaries, i as readScheduledAutomation, ir as getSubscribedReplyPreflightDecision, it as recordAuthorizationCompleted, j as resolveTurnSessionRouting, kt as turnHasReply, o as saveScheduledAutomationInLock, pr as configValueSchema, pt as persistConversationMessages, q as commitMessages, qt as completeTurnRecord, r as parseScheduledAutomationRow, rr as decideSubscribedThreadReply, tr as buildDeterministicTurnId, ur as isExperimentalFeatureEnabled, vt as fallbackShortTitle, w as listAutomationVersions, wt as getConversationMessageSlackTs, xt as buildConversationContext } from "./tasks-SB9z-VTU.js";
+import { a as completeText, p as escapeXml, r as completeDecision, y as isProviderRetryError } from "./client-C1yDYjoS.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-DrTeF80T.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-DLSpkSSr.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, g as parseSlackMessageTs, i as isActorUserId, l as parseSlackChannelId, n as createSlackActor, o as parseActorUserId, r as createSlackResumeActor, t as createActor } from "./actor-tlxzqaRe.js";
-import { B as requireSlackDestination, R as createSlackDestination, d as getConversationStore, f as getDb, l as getConversationEventStore, p as getSqlExecutor } from "./viewer-BpE6Z3qf.js";
-import { c as juniorIdentities, d as juniorDestinations, l as juniorUsers } from "./agent-invocations-CxKldAeB.js";
-import { a as juniorAutomationRuns, s as juniorAutomations } from "./executor-TnWbvL09.js";
-import { p as instructionProvenanceFor } from "./history-C84mlAwO.js";
-import { d as actorLogContext, f as credentialContextForActor } from "./registry-1BEIPdbT.js";
-import { A as listThreadReplies, D as resolveSlackChannelIdFromMessage, E as readSlackRawMessageContext, I as describeEventAutomationTrigger, L as effectiveTaskOutcomes, O as resolveSlackChannelIdFromThreadId, Q as RetryableDeliveryError, T as parseSlackThreadId, X as buildSteeringPiMessage, Z as withoutSavedSteeringMessages, b as renderBlockText, i as buildAuthPauseResponse, k as getConversationInfo, n as executeAgentRun, nt as shouldEmitDevAgentTrace, p as latestProgressStatus, r as createContextCompactor, t as createAgentRunner, w as storeAttachment, y as renderAttachmentText } from "./agent-runner-BtYK7bht.js";
-import { $t as getHeaderString, Kn as readAttachmentVisionSummary, Nt as cancelSubscriptions, Un as buildSentryConversationUrl, Wn as getSlackFileId, Xt as SlackActionError, Yt as verifyTimerWatchCredentialSubject, Zt as downloadPrivateSlackFile, dn as getDashboardObjectIconLink, dt as normalizeSlackReplyMarkdown, en as getSlackClient, ft as normalizeSlackStatusText, ht as addReactionToMessage, in as runWithSlackInstallationToken, l as getPluginSlackConversationLink, ln as JUNIOR_THREAD_STATE_TTL_MS, lt as escapeSlackMrkdwnText, mt as truncateStatusText, n as createUserTokenStore, nn as isDmChannel, qn as recordSlackAttachment, rn as normalizeSlackConversationId, tr as lookupSlackUser, un as getDashboardConversationLink, ut as formatSlackLink, vt as postSlackMessage, yt as removeReactionFromMessage } from "./credentialed-enF5Bf3y.js";
-import { a as acquireActiveLock, i as MUTATION_LOCK_TTL_MS, r as getStateAdapter, s as withLock } from "./adapter-eRFA_naf.js";
-import { B as readMessageAttachments, U as isVisionImageMediaType } from "./conversation-DF4rUcjb.js";
-import { a as EVENT_SYSTEM_ACTOR, o as isEventConversationMessage } from "./prompt-BcCGlmg2.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-DcKkzrdt.js";
-import { n as getAssistantReplyText } from "./assistant-reply-UyzAfZQo.js";
-import { B as finishedRunReply, F as recordFinishedTurnForAutomatedLimit, M as joinMailboxText, P as maybePostAutomatedTurnLimitNotice, U as runDispatchOutcome, c as isEventMailboxMetadata, d as getEventCatalog, i as skipInputBeforeConversationStop, l as renderEventBatchText, s as eventBatchMessageEvents, u as timerWatchCredentialSubject, x as automationEventCatalog, z as deliversFinalText } from "./session-stop-tZOw9AJD.js";
-import { a as getVercelConversationWorkQueue, f as getTurnRequestDeadline } from "./job-queue-DBpHmKnd.js";
-import { E as stopConversationWork, g as getConversationWorkState, h as getConversation, m as ensureConversationWake, n as appendAndEnqueueExclusiveInboundMessage, r as appendAndEnqueueInboundMessage, w as requestConversationWork } from "./store-FALy-JQb.js";
-import { l as automationListQuerySchema } from "./automation-BKpY9LPa.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, 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-8N5LIkSg.js";
-import { a as withAgentInvocationResultActors, c as resolveMailboxTurnWork, i as startAgentInvocationsForChildInput, l as sourceFromTurnInput, o as getAuthPausedConversationTurnId, s as getEventBatchDelayMs, t as enqueueAgentInvocationResult, u as turnInputFactsFromConversationMessage } from "./result-CwOpzqdh.js";
-import { n as getTurnLifecycle, t as ConversationTurnLifecycleService } from "./turn-lifecycle-DaBVoz7h.js";
-import { i as resolveAgentInvocationId, o as AgentRunError, s as executeTurn, t as createAgentInvocationWorker } from "./work-VX1SHWha.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-cprEaxgl.js";
-import { c as deleteWebAuthorization, d as createPausedTurns, f as getPausedTurnRequest, h as getTurnAuthorization, m as wakePausedTurn, s as createWebAuthorization } from "./connections-Bwu3VORi.js";
-import { n as resolveTurnSessionRouting } from "./turn-session-routing-a9CHX-w6.js";
-import { t as bindMessageAgent } from "./message-VZ3DFpGb.js";
-import { t as bindSpawnAgent } from "./spawn-6rokq7l_.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-C8sMdsdX.js";
-import { r as storeInputImages } from "./images-BKQqSi5W.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 { L as hasAgentTurnUsage, M as parseSessionSource, N as addAgentTurnUsage, V as requireSlackDestination, _ as withConversationEventLock, d as getConversationEventStore, h as getSqlExecutor, m as getDb, p as getConversationStore, v as loadConversationSlackTenantIds, x as locationFromRow, z as createSlackDestination } from "./viewer-CpXTGlep.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, d as juniorAutomations, g as juniorConversationBriefs, l as juniorAutomationRuns, y as juniorConversationEvents } from "./executor-4vhvsMZJ.js";
+import { d as contextProvenance, p as instructionProvenanceFor } from "./history-C84mlAwO.js";
+import { d as actorLogContext, f as credentialContextForActor } from "./registry-BgecKva0.js";
+import { A as getConversationInfo, D as readSlackRawMessageContext, E as parseSlackThreadId, Ft as buildSteeringPiMessage, H as syncReviewItemSlackCards, It as withoutSavedSteeringMessages, L as describeEventAutomationTrigger, Mt as conversationSubtreeColumns, O as resolveSlackChannelIdFromMessage, R as effectiveTaskOutcomes, Ut as shouldEmitDevAgentTrace, _t as recordWebConversationActivity, at as getReviewItem, b as renderBlockText, dt as sendReviewItemMessages, et as runWithSlackInstallation, gt as createConversationId, i as buildAuthPauseResponse, j as listThreadReplies, jt as conversationSubtree, k as resolveSlackChannelIdFromThreadId, lt as takeReviewItem, n as executeAgentRun, nt as canReadReviewItem, p as latestProgressStatus, r as createContextCompactor, rt as closeReviewItem, st as reviewItemReaderForUser, t as createAgentRunner, vt as webActorFromEmail, wt as storeAttachment, y as renderAttachmentText, yt as resolveConversationDestination, zt as RetryableDeliveryError } from "./agent-runner-CAYfFmU7.js";
+import { $n as recordSlackAttachment, $t as verifyTimerWatchCredentialSubject, Bn as conversationArchivedForUser, Gn as viewerConversationMembership, Hn as conversationIsMemberRoot, In as createPluginLogger, J as truncateStatusText, K as normalizeSlackStatusText, Ln as readConversationAccessFromSql, Lt as cancelSubscriptions, Qn as readAttachmentVisionSummary, Rn as conversationArchiveTimes, Un as conversationNotArchivedForEmail, Vn as conversationHasParticipantUser, Wn as conversationNotArchivedForUser, Xn as getSlackFileId, Y as addReactionToMessage, cr as createPluginCache, en as SlackActionError, in as getSlackClient, ir as listConversationAnnotationsById, ln as withSlackRetries, n as createUserTokenStore, nt as removeReactionFromMessage, on as isDmChannel, p as getPlugins, pn as JUNIOR_THREAD_STATE_TTL_MS, rn as getHeaderString, sn as normalizeSlackConversationId, sr as lookupSlackUser, tn as downloadPrivateSlackFile, zn as conversationArchivedForEmail } from "./credentialed-lukuD-cc.js";
+import { a as MUTATION_LOCK_TTL_MS, c as withLock, i as getStateAdapter, o as acquireActiveLock } from "./adapter-04AcD2SO.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-C5PN02QO.js";
+import { r as getAssistantReplyText } from "./interruption-marker-CkncDT8d.js";
+import { C as maybePostAutomatedTurnLimitNotice, D as recordFinishedTurnForAutomatedLimit, I as runDispatchOutcome, M as finishedRunReply, N as postsRunNotices, T as sendSlackReply, c as isEventMailboxMetadata, d as getEventCatalog, i as skipInputBeforeConversationStop, j as deliversFinalText, l as renderEventBatchText, s as eventBatchMessageEvents, u as timerWatchCredentialSubject, w as resolveSlackReplyTarget, x as joinMailboxText } from "./session-stop-Dam1EI7B.js";
+import { a as isEmptyUserInputAnswer, o as normalizeUserInputAnswer } from "./web-message-id-DlHNANtd.js";
+import { a as getVercelConversationWorkQueue, f as getTurnRequestDeadline } from "./job-queue-In9QKz-I.js";
+import { D as stopConversationWork, g as getConversationWorkState, h as getConversation, m as ensureConversationWake, r as appendAndEnqueueInboundMessage, w as requestConversationWork } from "./store-zPEoJPBB.js";
+import { j as eventAutomationTriggerSchema, l as automationListQuerySchema } from "./automation-CmeFBSEh.js";
+import { p as healthReportSchema, s as sumUtcHoursIntoSixHours } from "./reporting-window-DVCD_10C.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-DMI2prDO.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-D3TSmZZ8.js";
+import { n as getTurnLifecycle, t as ConversationTurnLifecycleService } from "./turn-lifecycle-oP0kVeGz.js";
+import { i as resolveAgentInvocationId, o as AgentRunError, s as executeTurn, t as createAgentInvocationWorker } from "./work-3N-GHY9m.js";
+import { a as persistThreadStateById, i as persistThreadRuntimeState, n as getPersistedSandboxState, o as coerceThreadConversationState, r as getPersistedThreadState, t as getLocationConfigurationService } from "./thread-state-BbbPh0Sn.js";
+import { c as deleteWebAuthorization, d as createPausedTurns, f as getPausedTurnRequest, h as getTurnAuthorization, m as wakePausedTurn, s as createWebAuthorization } from "./connections-D46f8vvi.js";
+import { t as bindMessageAgent } from "./message-BObyg59s.js";
+import { t as bindSpawnAgent } from "./spawn-cmq9p4Ly.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-BKKmnMB5.js";
 import { z } from "zod";
 import { createHash } from "node:crypto";
-import { and, asc, count, desc, eq, exists, inArray, ne, or, sql } from "drizzle-orm";
-import { createSlackSource, createWebSource, localDestinationSchema, objectFactFields, objectPresentation, objectTypeSchema } from "@sentry/junior-plugin-api";
+import { and, asc, count, desc, eq, exists, inArray, isNotNull, isNull, ne, notInArray, 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";
 import { SlackFormatConverter, createSlackAdapter } from "@chat-adapter/slack";
@@ -107,8 +108,7 @@ async function enqueueAgentDispatch(dispatch, options) {
 		destination: claimedDispatch.destination,
 		nowMs,
 		source: "plugin",
-		sessionSource: claimedDispatch.source,
-		visibility: claimedDispatch.destinationVisibility
+		sessionSource: claimedDispatch.source
 	});
 	await appendAndEnqueueInboundMessage({
 		message: buildAgentDispatchInboundMessage(claimedDispatch, nowMs),
@@ -213,7 +213,6 @@ async function persistBlockedDispatchTurn(dispatch, error) {
 		actor: dispatch.actor,
 		conversationId,
 		destination: dispatch.destination,
-		destinationVisibility: dispatch.destinationVisibility,
 		dispatchId: dispatch.id,
 		dispatchOutcome: "blocked",
 		turnId: sessionId,
@@ -380,207 +379,140 @@ 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;
+	}
+};
+/**
+* Return whether a User can act on an open Review item: an assigned User,
+* anyone for an item assigned to Everyone, and anyone for an item with no
+* assignees. The caller checks that the User can see the item.
+*/
+function canActOnReviewItem(item, userId) {
+	if (item.status !== "open") return false;
+	if (item.assignedToEveryone) return true;
+	if (item.assignees.length === 0) return true;
+	return item.assignees.some((assignee) => assignee.userId === userId);
+}
+/** Return whether a User is already the only assignee, so take does nothing. */
+function isOnlyAssignee(item, userId) {
+	return !item.assignedToEveryone && item.assignees.length === 1 && item.assignees[0]?.userId === userId;
+}
+/** 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. */
+function isSameClose(item, action, user) {
+	return 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 Slack card click, 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. Slack cards of the item
+* change in place; see `syncReviewItemSlackCards` for `getSlackAdapter`.
+*/
+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 syncReviewItemSlackCards({
+			getSlackAdapter: args.getSlackAdapter,
+			itemId: taken.id
+		});
+		await sendReviewItemMessages({
+			change: reviewItemChange(action, user),
+			exceptConversationId: args.exceptConversationId,
+			item: taken,
+			nowMs,
+			queue: args.queue
+		});
+		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 syncReviewItemSlackCards({
+		getSlackAdapter: args.getSlackAdapter,
+		itemId: closed.id
+	});
+	await sendReviewItemMessages({
+		change: reviewItemChange(action, user),
+		exceptConversationId: args.exceptConversationId,
+		item: closed,
+		nowMs,
+		queue: args.queue
+	});
+	return closed;
 }
 // src/chat/slack/errors.ts
 /** Extract Slack's stable API error code from Web API errors. */
@@ -850,6 +782,36 @@ async function startProcessingReactionForMessage(args) {
 	};
 }
 // src/chat/providers/slack/turn-input-telemetry.ts
+const SENTRY_TRACE_PATTERN = /^([0-9a-f]{32})-([0-9a-f]{16})(?:-([01]))?$/;
+function spanLinks({ sentryTrace }) {
+	const [, traceId, spanId, sampled] = SENTRY_TRACE_PATTERN.exec(sentryTrace) ?? [];
+	return traceId && spanId ? [{ context: {
+		traceId,
+		spanId,
+		traceFlags: sampled === "1" ? 1 : 0
+	} }] : [];
+}
+/**
+* Run a `chat.turn` span in the trace of the first trace context.
+*
+* The span links to the other trace contexts and to the span that was active,
+* such as the worker span. Without a trace context, the span is a child of the
+* active span. A malformed trace context starts a new trace.
+*/
+async function withTurnSpan(context, input, callback) {
+	const [parent, ...others] = input?.traceContexts ?? [];
+	if (!parent) return await withSpan("chat.turn", "chat.turn", context, callback);
+	const activeSpan = getActiveSpan();
+	const links = [...others.flatMap(spanLinks), ...activeSpan ? [{ context: activeSpan.spanContext() }] : []];
+	const { baggage, sentryTrace } = parent;
+	return await continueTrace({
+		baggage,
+		sentryTrace
+	}, () => withSpan("chat.turn", "chat.turn", context, async (setSpanAttributes) => {
+		getActiveSpan()?.addLinks(links);
+		return await callback(setSpanAttributes);
+	}));
+}
 /**
 * Build the `chat.turn` timing attributes for the oldest input message.
 *
@@ -1010,10 +972,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,
@@ -1058,7 +1018,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",
@@ -1114,14 +1082,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,
@@ -1169,7 +1137,7 @@ function createSlackTurnRuntime(deps) {
 			});
 			logSkippedSubscribedDecision(skipped);
 			await deps.recordSkippedSteeringMessage({
-				thread: args.thread,
+				conversationId: args.conversationId,
 				message: skipped.message,
 				decision: skipped.decision,
 				text: skipped.text
@@ -1183,7 +1151,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
@@ -1197,6 +1165,7 @@ function createSlackTurnRuntime(deps) {
 	};
 	return {
 		async handleNewMention(thread, message, hooks) {
+			const conversationId = hooks.conversationId ?? thread.id;
 			const processingReactions = createProcessingReactionTracker(thread);
 			let processingReaction;
 			const skippedSteeringMessages = [];
@@ -1205,7 +1174,7 @@ function createSlackTurnRuntime(deps) {
 			const onTurnCompleted = async () => {
 				completed = true;
 				await flushSkippedSteeringMessagesBestEffort({
-					thread,
+					conversationId,
 					pending: skippedSteeringMessages,
 					context: logContext({
 						threadId: getThreadId(thread, message),
@@ -1233,7 +1202,7 @@ function createSlackTurnRuntime(deps) {
 				}
 				processingReaction = await processingReactions.start(context, message);
 				const toolInvocationHook = createToolInvocationHook(processingReaction, hooks);
-				await withSpan("chat.turn", "chat.turn", context, async (set) => {
+				await withTurnSpan(context, hooks.telemetry, async (set) => {
 					const turnStartedAtMs = deps.now();
 					if (hooks.telemetry) set(getTurnInputSpanAttributes(hooks.telemetry, turnStartedAtMs));
 					const queuedMessages = getQueuedMessages(hooks.messageContext, {
@@ -1259,6 +1228,7 @@ function createSlackTurnRuntime(deps) {
 						},
 						onSkipped: (skipped) => handleSkippedSteeringMessages({
 							beforeFirstResponsePost: hooks.beforeFirstResponsePost,
+							conversationId,
 							pending: skippedSteeringMessages,
 							skipped,
 							thread
@@ -1272,7 +1242,7 @@ function createSlackTurnRuntime(deps) {
 					await deps.executeSlackTurn(thread, message, {
 						explicitMention: true,
 						beforeFirstResponsePost: hooks.beforeFirstResponsePost,
-						conversationId: hooks.conversationId,
+						conversationId,
 						destination: hooks.destination,
 						queuedMessages,
 						ack,
@@ -1309,17 +1279,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"
@@ -1329,7 +1301,7 @@ function createSlackTurnRuntime(deps) {
 				if (completed) await processingReactions.completeAll();
 				else {
 					await flushSkippedSteeringMessagesBestEffort({
-						thread,
+						conversationId,
 						pending: skippedSteeringMessages,
 						context: logContext({
 							threadId: getThreadId(thread, message),
@@ -1344,6 +1316,7 @@ function createSlackTurnRuntime(deps) {
 			}
 		},
 		async handleSubscribedMessage(thread, message, hooks) {
+			const conversationId = hooks.conversationId ?? thread.id;
 			const processingReactions = createProcessingReactionTracker(thread);
 			let processingReaction;
 			const skippedSteeringMessages = [];
@@ -1352,7 +1325,7 @@ function createSlackTurnRuntime(deps) {
 			const onTurnCompleted = async () => {
 				completed = true;
 				await flushSkippedSteeringMessagesBestEffort({
-					thread,
+					conversationId,
 					pending: skippedSteeringMessages,
 					context: logContext({
 						threadId: getThreadId(thread, message),
@@ -1375,7 +1348,7 @@ function createSlackTurnRuntime(deps) {
 					channelId,
 					runId
 				});
-				await withSpan("chat.turn", "chat.turn", turnContext, async (set) => {
+				await withTurnSpan(turnContext, hooks.telemetry, async (set) => {
 					const turnStartedAtMs = deps.now();
 					if (hooks.telemetry) set(getTurnInputSpanAttributes(hooks.telemetry, turnStartedAtMs));
 					const content = parseContent(message);
@@ -1388,6 +1361,7 @@ function createSlackTurnRuntime(deps) {
 						userText: replaceTopLevelText(content, strippedUserText)
 					};
 					const threadContext = {
+						conversationId,
 						threadId,
 						actorId,
 						channelId,
@@ -1420,7 +1394,7 @@ function createSlackTurnRuntime(deps) {
 							beforeFirstResponsePost: hooks.beforeFirstResponsePost
 						});
 						await skipSubscribedMessage({
-							thread,
+							conversationId,
 							message,
 							decision,
 							context: threadContext,
@@ -1438,7 +1412,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,
@@ -1464,7 +1438,7 @@ function createSlackTurnRuntime(deps) {
 							beforeFirstResponsePost: hooks.beforeFirstResponsePost
 						});
 						await skipSubscribedMessage({
-							thread,
+							conversationId,
 							message,
 							decision,
 							context: threadContext,
@@ -1483,7 +1457,7 @@ function createSlackTurnRuntime(deps) {
 						queuedMessages
 					});
 					await deps.persistPreparedState({
-						thread,
+						conversationId,
 						preparedState
 					});
 					const decision = await deps.decideSubscribedReply({
@@ -1500,7 +1474,7 @@ function createSlackTurnRuntime(deps) {
 						beforeFirstResponsePost: hooks.beforeFirstResponsePost
 					})) {
 						await skipSubscribedMessage({
-							thread,
+							conversationId,
 							message,
 							decision,
 							context: threadContext,
@@ -1512,7 +1486,7 @@ function createSlackTurnRuntime(deps) {
 					}
 					if (!decision.shouldReply) {
 						await skipSubscribedMessage({
-							thread,
+							conversationId,
 							message,
 							decision,
 							context: threadContext,
@@ -1531,6 +1505,7 @@ function createSlackTurnRuntime(deps) {
 						},
 						onSkipped: (skipped) => handleSkippedSteeringMessages({
 							beforeFirstResponsePost: hooks.beforeFirstResponsePost,
+							conversationId,
 							pending: skippedSteeringMessages,
 							skipped,
 							thread
@@ -1556,7 +1531,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,
@@ -1595,17 +1570,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"
@@ -1615,7 +1592,7 @@ function createSlackTurnRuntime(deps) {
 				if (completed) await processingReactions.completeAll();
 				else {
 					await flushSkippedSteeringMessagesBestEffort({
-						thread,
+						conversationId,
 						pending: skippedSteeringMessages,
 						context: logContext({
 							threadId: getThreadId(thread, message),
@@ -2166,7 +2143,8 @@ function createSlackConversationWorker(options) {
 		const telemetry = {
 			count: records.length,
 			oldestCreatedAtMs: oldestRecord.createdAtMs,
-			oldestReceivedAtMs: oldestRecord.receivedAtMs
+			oldestReceivedAtMs: oldestRecord.receivedAtMs,
+			traceContexts: records.flatMap((record) => record.traceContext ?? [])
 		};
 		const latestMetadata = parseSlackMetadata(latestRecord.input.metadata);
 		if (!latestMetadata) throw new Error("Latest conversation mailbox record is not Slack metadata");
@@ -2213,7 +2191,7 @@ function createSlackConversationWorker(options) {
 				};
 				const drainSteeringMessages = async (accept) => {
 					await context.attempt.drain(async (pendingRecords) => {
-						const candidates = pendingRecords.map((record) => ({
+						const candidates = pendingRecords.filter((record) => record.source === "slack").map((record) => ({
 							inboundMessageId: record.inboundMessageId,
 							message: restoreMessage({
 								adapter,
@@ -2263,7 +2241,7 @@ function createSlackConversationWorker(options) {
 		return { status: "completed" };
 	};
 }
-/** Serialize a Slack message into the generic durable conversation mailbox. */
+/** Serialize a Slack message and the active trace into the durable mailbox. */
 function buildSlackInboundMessage(args) {
 	const authorId = requireSlackAuthorId(args.message);
 	const destination = createSlackDestination({
@@ -2296,7 +2274,8 @@ function buildSlackInboundMessage(args) {
 				thread: serializedThreadSchema.parse(args.thread.toJSON()),
 				message: args.message.toJSON()
 			}
-		}
+		},
+		traceContext: getActiveTraceContext()
 	};
 }
 // src/chat/slack/message/identity.ts
@@ -2784,6 +2763,57 @@ function recordSkippedConversationMessage(args) {
 		}
 	});
 }
+// src/chat/sign-in/allowlist.ts
+/**
+* Domains that may use Junior. Slack authors must have a Slack profile email
+* on one of them, and dashboard Google sign-ins must come from a Google
+* Workspace account whose `hd` claim is one of them. Slack and the dashboard
+* share one list.
+*/
+/** Read a list env var: a JSON string array or comma-separated values. */
+function readEnvList(name) {
+	const value = process.env[name]?.trim();
+	if (!value) return void 0;
+	if (!value.startsWith("[")) return value.split(",");
+	let parsed;
+	try {
+		parsed = JSON.parse(value);
+	} catch (error) {
+		throw new Error(`${name} must be a JSON string array`, { cause: error });
+	}
+	const list = z.array(z.string()).safeParse(parsed);
+	if (!list.success) throw new Error(`${name} must be a JSON string array`);
+	return list.data;
+}
+/**
+* Resolve the allowed domains: the `createApp` option when set, else
+* `JUNIOR_ALLOWED_DOMAINS`. An empty list allows every domain.
+*/
+function resolveAllowedDomains(allowedDomains) {
+	return [...new Set((allowedDomains ?? readEnvList("JUNIOR_ALLOWED_DOMAINS") ?? []).map((value) => value.trim().toLowerCase()).filter(Boolean))];
+}
+/**
+* Fail startup on the removed Google-specific names. Ignoring them would
+* leave the list empty, which lets every Slack workspace member in.
+*/
+function assertNoLegacyAllowedDomains(dashboardOptionKeys) {
+	if (dashboardOptionKeys.includes("allowedGoogleDomains")) throw new Error("dashboard.allowedGoogleDomains was removed; set createApp({ allowedDomains }) instead");
+	if (process.env.JUNIOR_DASHBOARD_GOOGLE_DOMAINS?.trim()) throw new Error("JUNIOR_DASHBOARD_GOOGLE_DOMAINS was removed; set JUNIOR_ALLOWED_DOMAINS instead");
+}
+/** Return whether a verified domain may use Junior. An empty list allows all. */
+function isAllowedDomain(domain, allowedDomains) {
+	if (allowedDomains.length === 0) return true;
+	return Boolean(domain && allowedDomains.includes(domain.toLowerCase()));
+}
+/**
+* Return whether a verified sign-in email is on an allowed domain. Sign-in
+* needs a configured list, so an empty list allows no email.
+*/
+function isAllowedSignInEmail(email, allowedDomains) {
+	const normalized = email.trim().toLowerCase();
+	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.
@@ -2799,18 +2829,6 @@ function viewerAutomationCollection(user) {
 	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 trigger = sql`${automation.record}->'trigger'`;
-	const match = sql`coalesce(${trigger}->'match', '{}'::jsonb)`;
-	const json = (value) => sql`${JSON.stringify(value)}::jsonb`;
-	const fieldWorks = (key, field) => {
-		const value = sql`${match}->(${key}::text)`;
-		const type = sql`jsonb_typeof(${value})`;
-		return sql`(${value} is null or (${and(field.events ? sql`${trigger}->'events' <@ ${json(field.events)}` : void 0, field.kind === "boolean" ? sql`${type} = 'boolean'` : sql`(${type} = ${field.kind} or (${type} = 'array' and not exists (select 1 from jsonb_array_elements(${value}) entry where jsonb_typeof(entry) <> ${field.kind})))`, field.enum ? sql`${value} <@ ${json(field.enum)}` : void 0)}))`;
-	};
-	const available = or(isScheduled, ...Object.entries(automationEventCatalog(getEventCatalog())).flatMap(([namespace, registration]) => registration.resourceTypes.map((resourceType) => {
-		const fields = Object.entries(resourceType.matchFields ?? {});
-		return and(eq(automation.namespace, namespace), sql`${trigger}->>'resourceType' = ${resourceType.type}`, sql`${trigger}->'events' <@ ${json(resourceType.supportedEvents)}`, sql`not exists (select 1 from jsonb_object_keys(${match}) match_key where not (${json(fields.map(([key]) => key))} @> to_jsonb(match_key)))`, ...fields.map(([key, field]) => fieldWorks(key, field)));
-	}))) ?? sql`false`;
 	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
@@ -2821,8 +2839,8 @@ function viewerAutomationCollection(user) {
 		title: automation.title,
 		createdAtMs: automation.createdAtMs,
 		state: sql`${automation.status}`.as("state"),
-		unavailable: sql`not (${available})`.as("unavailable"),
-		attention: sql`${automation.status} not in ('paused', 'completed') and (${automation.status} = 'blocked' or not (${available}) or ${lastRunNeedsAttention})`.as("attention"),
+		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"),
@@ -2833,11 +2851,29 @@ function viewerAutomationCollection(user) {
 		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 where = and(input.scope === "mine" ? eq(collection.owned, true) : input.scope === "public" ? eq(collection.isPublic, true) : input.scope === "attention" ? eq(collection.attention, true) : void 0, input.type === "all" ? void 0 : eq(collection.kind, input.type), input.state === "all" ? void 0 : input.state === "unavailable" ? eq(collection.unavailable, true) : 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 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({
@@ -2966,6 +3002,7 @@ function executionSummaryFields(stats) {
 		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
 	};
@@ -3019,7 +3056,7 @@ function eventAutomationSummary(task, ownedByViewer, destination, stats, creator
 		kind: "event",
 		...executionSummaryFields(stats),
 		ownedByViewer,
-		resource: `${task.trigger.label} · ${task.trigger.identifier}`,
+		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),
@@ -3502,292 +3539,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: "…",
@@ -4289,8 +4040,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
@@ -4327,10 +4078,7 @@ function createSlackTurn(deps) {
 			channelName,
 			channelType: slackChannelType
 		});
-		const destinationVisibility = await resolveDestinationVisibility({
-			destination,
-			visibility: options.execution?.destinationVisibility ?? conversationVisibilityFromSlackChannelType(slackChannelType)
-		});
+		const destinationVisibility = conversationVisibilityFromSlackChannelType(slackChannelType);
 		const assistantThreadContext = getAssistantThreadContext(message);
 		const threadTs = getThreadTs(threadId) ?? assistantThreadContext?.threadTs;
 		const messageTs = getMessageTs(message);
@@ -4340,7 +4088,14 @@ function createSlackTurn(deps) {
 			messageTs,
 			teamId,
 			threadTs,
-			visibility: destinationVisibility ?? "private"
+			visibility: await resolveDestinationVisibility({
+				destination,
+				visibility: destinationVisibility
+			}) ?? "private"
+		});
+		const replyTarget = resolveSlackReplyTarget({
+			destination,
+			source
 		});
 		const slackActionToken = readSlackActionToken(message);
 		const runId = options.execution?.dispatch?.id ?? getRunId(thread, message);
@@ -4396,6 +4151,7 @@ function createSlackTurn(deps) {
 				destination,
 				locationConfiguration: options.execution?.locationConfiguration,
 				context: {
+					conversationId,
 					threadId,
 					actorId: slackActorId,
 					channelId,
@@ -4413,17 +4169,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",
@@ -4477,7 +4232,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?.();
@@ -4500,7 +4255,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;
@@ -4538,7 +4293,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
@@ -4557,7 +4316,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;
@@ -4598,7 +4357,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,
@@ -4685,16 +4444,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) {
@@ -4784,7 +4542,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);
@@ -4893,11 +4651,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 });
 						}
 					}
 				};
@@ -4976,7 +4734,7 @@ function createSlackTurn(deps) {
 							conversation: completedState.conversation,
 							conversationId
 						}));
-						await persistThreadRuntimeStateWithRetry(thread, completedState);
+						await persistThreadRuntimeStateWithRetry(conversationId, completedState);
 						const automatedTurnLimit = await recordFinishedTurnForAutomatedLimit({
 							conversationId,
 							maxTurns: botConfig.maxConsecutiveAutomatedTurns,
@@ -4985,7 +4743,7 @@ function createSlackTurn(deps) {
 						await maybePostAutomatedTurnLimitNotice({
 							conversationId,
 							maxTurns: botConfig.maxConsecutiveAutomatedTurns,
-							threadTs,
+							source,
 							update: automatedTurnLimit
 						});
 					} catch (saveError) {
@@ -5021,7 +4779,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(),
@@ -5038,7 +4796,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;
@@ -5122,7 +4880,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(),
@@ -5179,7 +4937,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();
@@ -5318,10 +5076,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,
@@ -5448,7 +5206,6 @@ function createSlackDispatchTurnRunner(options) {
 				disabledFeatures: ["interactive-auth"],
 				locationConfiguration: options.getLocationConfiguration(dispatch.destination),
 				credentialContext: routing.credentialContext,
-				destinationVisibility: dispatch.destinationVisibility,
 				dispatch: routing.dispatch,
 				skipProviderDefaultConfig: true,
 				source: dispatch.source,
@@ -5507,8 +5264,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) => {
@@ -5523,18 +5280,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,
@@ -5543,16 +5300,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 }) => {
@@ -5599,23 +5356,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. */
@@ -5656,13 +5410,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);
@@ -5686,12 +5433,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 {
@@ -5767,7 +5509,7 @@ function buildResumedRun(args, statusSession, delivery) {
 * generation begins.
 */
 async function resumeSlackTurn(args) {
-	return withLogContext(getResumeLogContext(args), () => resumeSlackTurnInContext(args));
+	return await withTurnSpan(getResumeLogContext(args), args.traceContext && { traceContexts: [args.traceContext] }, () => resumeSlackTurnInContext(args));
 }
 async function resumeSlackTurnInContext(args) {
 	const status = createSlackWebApiAssistantStatusSession({
@@ -5810,10 +5552,9 @@ 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 visibility = (await getConversationStore().get({ conversationId }))?.visibility;
 		const visibleConversationId = args.conversationId;
 		const sessionId = runArgs.turnId;
 		let deliveryConversation;
@@ -5908,7 +5649,6 @@ async function resumeSlackTurnInContext(args) {
 				await persistWithRetry(() => recordTurnSummary({
 					conversationId: runArgs.conversationId,
 					destination: savedRun.destination,
-					destinationVisibility: visibility,
 					dispatchId,
 					resultMessageId: messageTs,
 					turnId: runArgs.turnId,
@@ -5954,7 +5694,6 @@ async function resumeSlackTurnInContext(args) {
 				durationMs: reply.diagnostics.durationMs,
 				usage: reply.diagnostics.usage,
 				destination: run.destination,
-				destinationVisibility: visibility,
 				dispatchId: run.dispatch?.id,
 				dispatchOutcome: dispatchResult.outcome,
 				...dispatchErrorMessage ? { errorMessage: dispatchErrorMessage } : void 0,
@@ -5967,7 +5706,6 @@ async function resumeSlackTurnInContext(args) {
 			else if (run.dispatch?.id) await recordTurnSummary({
 				conversationId: runArgs.conversationId,
 				destination: run.destination,
-				destinationVisibility: visibility,
 				dispatchId: run.dispatch?.id,
 				dispatchOutcome: dispatchResult.outcome,
 				...acceptedDeliveryId ? { resultMessageId: acceptedDeliveryId } : void 0,
@@ -6069,7 +5807,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({
@@ -6262,15 +6000,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,
-		channelId: thread?.channelId ?? destination.channelId,
-		...thread?.threadTs ? { threadTs: thread.threadTs } : void 0,
+		traceContext: payload.traceContext,
+		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 () => {
@@ -6483,6 +6228,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 });
@@ -6493,22 +6255,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;
@@ -6653,28 +6408,67 @@ async function commitAssistantMessage(args) {
 		logException(error, "conversation.assistant.message_persist.failed");
 	}
 }
-// 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;
+// src/chat/task-execution/web-steering.ts
+function steeringMessageFromWeb(message, actor) {
+	const storedAttachments = readMessageAttachments(message.input.attachments);
+	return {
+		actor: {
+			authorId: actor.userId,
+			...actor.fullName ? { authorName: actor.fullName } : void 0
+		},
+		provenance: instructionProvenanceFor(actor),
+		text: message.input.text.trim(),
+		timestampMs: message.createdAtMs,
+		...storedAttachments.length ? { storedAttachments } : void 0
+	};
 }
 /**
-* Keep a stored Destination, or create the temporary local Destination.
+* Drain steered web messages into the active web Turn.
 *
-* TODO(dcramer): Delete this module after Conversation and AgentRun use
-* Location, and web and event Turns no longer need a local
-* Destination.
+* Only messages from the Turn Actor join. Steered messages from another
+* participant stay pending and start their own Turn next, so they never act
+* with this Actor's credentials.
 */
-function resolveConversationDestination(args) {
-	return args.existing ?? requireLocalDestination(args.conversationId);
+function createWebSteeringDrain(args) {
+	const { actor, author, context, conversation, turnId } = args;
+	return async (accept) => {
+		const accepted = [];
+		await context.attempt.drain(async (pending) => {
+			const joining = pending.filter((message) => message.source === "web" && message.input.authorId === actor.userId && legacyWebMailboxMetadataSchema.safeParse(message.input.metadata).success);
+			if (joining.length === 0) return [];
+			for (const message of joining) {
+				const attachments = readMessageAttachments(message.input.attachments);
+				upsertConversationMessage(conversation, {
+					id: message.inboundMessageId,
+					role: "user",
+					text: normalizeConversationText(message.input.text),
+					createdAtMs: message.createdAtMs,
+					author,
+					meta: {
+						...attachments.length ? { attachments } : void 0,
+						explicitMention: true,
+						source: "web"
+					}
+				});
+			}
+			await persistConversationMessages({
+				conversation,
+				conversationId: context.conversationId
+			});
+			const saved = (await getTurnRecord(context.conversationId, turnId))?.piMessages ?? [];
+			const messages = withoutSavedSteeringMessages(saved, joining.map((message) => steeringMessageFromWeb(message, actor)), buildSteeringPiMessage);
+			if (messages.length > 0) {
+				await accept(messages);
+				accepted.push(...messages);
+			}
+			return joining.map((message) => message.inboundMessageId);
+		});
+		return accepted;
+	};
 }
 // 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) {
@@ -6953,7 +6747,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,
@@ -6982,6 +6776,13 @@ function createConversationTurnWorker(agentRunner, deliverMessage) {
 					},
 					delivery: deliverAssistantMessage,
 					durability: {
+						...webActor ? { drainSteeringMessages: createWebSteeringDrain({
+							actor: webActor,
+							author,
+							context,
+							conversation,
+							turnId
+						}) } : void 0,
 						onInputCommitted: acknowledge,
 						shouldYield: context.shouldYield,
 						onSandboxRefChanged: async (nextSandboxRef) => {
@@ -7044,7 +6845,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";
@@ -7156,11 +6957,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) {
@@ -7320,165 +7123,1156 @@ function createProductionConversationWorkOptions(options) {
 		waitUntil: options.waitUntil
 	});
 }
-// src/chat/conversations/web-input.ts
-function normalizeEmail(email) {
-	return email.trim().toLowerCase();
+// src/chat/slack/location-url.ts
+/** Parse a Slack workspace subdomain used in `https://{domain}.slack.com` URLs. */
+function parseSlackTeamDomain(value) {
+	if (typeof value !== "string") return void 0;
+	const domain = value.trim().toLowerCase();
+	if (!/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(domain)) return;
+	return domain;
 }
-function stableHex(...parts) {
-	return createHash("sha256").update(parts.join("\0")).digest("hex").slice(0, 24);
+/** Convert a Slack message ts into the `p…` segment used by archive URLs. */
+function archivePathFromThreadTs(threadTs) {
+	const [seconds, fraction = ""] = threadTs.split(".");
+	return `p${seconds}${(fraction ?? "").padEnd(6, "0").slice(0, 6)}`;
 }
 /**
-* 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.
+* Build a direct Slack archive URL for a thread when the workspace domain is
+* known. Omits a link rather than falling back to `app_redirect`.
 */
-function createConversationId(args) {
-	return `local:web:${stableHex(normalizeEmail(args.actorEmail), args.idempotencyKey)}`;
+function buildSlackLocationUrl(args) {
+	const channelId = parseSlackChannelId(args.channelId);
+	const teamDomain = parseSlackTeamDomain(args.teamDomain);
+	const threadTs = parseSlackMessageTs(args.threadTs);
+	if (!channelId || !teamDomain || !threadTs) return void 0;
+	const url = new URL(`https://${teamDomain}.slack.com/archives/${channelId}/${archivePathFromThreadTs(threadTs)}`);
+	url.searchParams.set("thread_ts", threadTs);
+	url.searchParams.set("cid", channelId);
+	return url.toString();
+}
+// src/chat/slack/team-domain.ts
+const TEAM_DOMAIN_CACHE_TTL_MS = 864e5;
+const TEAM_DOMAIN_NEGATIVE_CACHE_TTL_MS = 6e4;
+const teamDomainCache = /* @__PURE__ */ new Map();
+const teamDomainInflight = /* @__PURE__ */ new Map();
+function readTeamDomainCache(teamId) {
+	const hit = teamDomainCache.get(teamId);
+	if (!hit) return void 0;
+	if (hit.expiresAt < Date.now()) {
+		teamDomainCache.delete(teamId);
+		return;
+	}
+	return hit.kind === "hit" ? hit.domain : null;
+}
+function writeTeamDomainCache(teamId, domain) {
+	if (domain) {
+		teamDomainCache.set(teamId, {
+			kind: "hit",
+			domain,
+			expiresAt: Date.now() + TEAM_DOMAIN_CACHE_TTL_MS
+		});
+		return;
+	}
+	teamDomainCache.set(teamId, {
+		kind: "miss",
+		expiresAt: Date.now() + TEAM_DOMAIN_NEGATIVE_CACHE_TTL_MS
+	});
+}
+async function fetchSlackTeamDomain(teamId) {
+	try {
+		const response = await withSlackRetries(() => getSlackClient().team.info({ team: teamId }), 3, {
+			action: "team.info",
+			idempotent: true,
+			spanAttributes: { "app.slack.team_id": teamId }
+		});
+		const responseTeamId = parseSlackTeamId(response.team?.id);
+		const domain = parseSlackTeamDomain(response.team?.domain);
+		if (!domain || !responseTeamId || responseTeamId !== teamId) {
+			writeTeamDomainCache(teamId, void 0);
+			return;
+		}
+		writeTeamDomainCache(teamId, domain);
+		return domain;
+	} catch {
+		writeTeamDomainCache(teamId, void 0);
+		return;
+	}
 }
-/** Return the stable Turn id for one mailbox Message. */
-function conversationTurnIdForMessage(messageId) {
-	return buildDeterministicTurnId(messageId);
+/** Resolve a workspace subdomain via `team.info`, cached by team id. */
+async function resolveSlackTeamDomain(teamId) {
+	const parsedTeamId = parseSlackTeamId(teamId);
+	if (!parsedTeamId) return void 0;
+	const cached = readTeamDomainCache(parsedTeamId);
+	if (cached !== void 0) return cached ?? void 0;
+	const pending = teamDomainInflight.get(parsedTeamId);
+	if (pending) return pending;
+	const lookup = fetchSlackTeamDomain(parsedTeamId).finally(() => {
+		teamDomainInflight.delete(parsedTeamId);
+	});
+	teamDomainInflight.set(parsedTeamId, lookup);
+	return lookup;
+}
+/** Resolve workspace subdomains for the distinct team ids in one API response. */
+async function resolveSlackTeamDomains(teamIds) {
+	const uniqueTeamIds = [...new Set([...teamIds].map((teamId) => parseSlackTeamId(teamId)).filter((teamId) => teamId !== void 0))];
+	const resolved = await Promise.all(uniqueTeamIds.map(async (teamId) => {
+		const domain = await resolveSlackTeamDomain(teamId);
+		return domain ? [teamId, domain] : void 0;
+	}));
+	return new Map(resolved.filter((entry) => entry !== void 0));
+}
+// src/api/conversations/shared.ts
+/** Format a Slack destination without exposing private channel names. */
+function slackStatsLocationLabel(input) {
+	const channelId = input.channel;
+	if (!channelId) return void 0;
+	if (input.channelNameRedacted && input.channelName) return input.channelName;
+	const name = input.channelName?.replace(/^#/, "");
+	if (channelId.startsWith("D")) return "Direct Message";
+	if (channelId.startsWith("C")) return name ? `#${name}` : "Public Channel";
+	if (channelId.startsWith("G")) {
+		if (name?.startsWith("mpdm-")) return "Group DM";
+		return "Private Channel";
+	}
+	return name || channelId;
+}
+/** Return the generic display label for a conversation surface. */
+function surfaceFallbackLabel(surface) {
+	if (surface === "scheduler") return "Scheduler";
+	if (surface === "api") return "API";
+	if (surface === "internal") return "Internal";
+	return "Conversation";
+}
+// src/api/conversations/projection.ts
+const PRIVATE_CONVERSATION_LABEL = "Private Conversation";
+function privateConversationLabel(slackConversation) {
+	if (!slackConversation) return PRIVATE_CONVERSATION_LABEL;
+	return slackConversation.visibility === "private" ? formatSlackConversationRedactedLabel(slackConversation) ?? PRIVATE_CONVERSATION_LABEL : PRIVATE_CONVERSATION_LABEL;
+}
+function surfaceFromConversationId(conversationId) {
+	if (parseSlackThreadId(conversationId)) return "slack";
+	if (conversationId.startsWith("scheduler:")) return "scheduler";
+	if (conversationId.startsWith("api:")) return "api";
+	return "internal";
+}
+function surfaceFromSource(source, conversationId) {
+	if (source === "slack" || source === "api" || source === "web" || source === "scheduler") return source === "web" ? "api" : source;
+	return surfaceFromConversationId(conversationId);
+}
+function locationUrlFromConversation(args) {
+	const { conversation } = args;
+	if (!args.canViewPrivateContent || conversation.location?.provider !== "slack") return;
+	const teamDomain = args.teamDomainByTeamId?.get(conversation.location.teamId);
+	const threadTs = conversation.location.threadTs;
+	if (!teamDomain || !threadTs) return void 0;
+	return buildSlackLocationUrl({
+		channelId: conversation.location.channelId,
+		teamDomain,
+		threadTs
+	});
 }
-/**
-* 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
+function actorIdentityReport(actor) {
+	if (!actor) return void 0;
+	const identity = {
+		...actor.email !== void 0 ? { email: actor.email } : void 0,
+		...actor.fullName !== void 0 ? { fullName: actor.fullName } : void 0,
+		...actor.slackUserId !== void 0 ? { slackUserId: actor.slackUserId } : void 0,
+		...actor.slackUserName !== void 0 ? { slackUserName: actor.slackUserName } : void 0
+	};
+	return Object.keys(identity).length > 0 ? identity : void 0;
+}
+function statusFromConversation(conversation) {
+	if (conversation.execution.status === "idle") return "completed";
+	if (conversation.execution.status === "failed") return "failed";
+	return "active";
+}
+function titleFromConversation(args) {
+	const slackThread = parseSlackThreadId(args.conversation.conversationId);
+	const effectiveChannelName = args.conversation.channelName;
+	const slackConversation = resolveSlackConversationContextFromThreadId({
+		threadId: args.conversation.conversationId,
+		channelName: effectiveChannelName,
+		...args.visibility ? { visibility: args.visibility } : void 0
+	});
+	return (args.canViewPrivateContent ? void 0 : privateConversationLabel(slackConversation)) ?? args.conversation.title ?? args.automationTitle ?? slackStatsLocationLabel({
+		channel: slackThread?.channelId,
+		channelName: effectiveChannelName
+	}) ?? (args.conversation.source === "plugin" ? "Automation run" : fallbackShortTitle(args.firstHumanMessageText ?? "", surfaceFallbackLabel(args.surface)));
+}
+function channelNameFromConversation(conversation, canViewPrivateContent, visibility) {
+	const effectiveChannelName = conversation.channelName;
+	const slackThread = parseSlackThreadId(conversation.conversationId);
+	if (!effectiveChannelName && !slackThread) return;
+	const slackConversation = resolveSlackConversationContextFromThreadId({
+		threadId: conversation.conversationId,
+		channelName: effectiveChannelName,
+		...visibility ? { visibility } : void 0
+	});
+	if (!canViewPrivateContent) return privateConversationLabel(slackConversation);
+	return effectiveChannelName;
+}
+function channelNameRedactedFromConversation(conversation, canViewPrivateContent) {
+	const effectiveChannelName = conversation.channelName;
+	const slackThread = parseSlackThreadId(conversation.conversationId);
+	if (!effectiveChannelName && !slackThread) return false;
+	return !canViewPrivateContent;
+}
+/** Describe whether a viewer can read one conversation's retained events. */
+function conversationEventHistory(args) {
+	if (args.transcriptPurgedAtMs !== void 0) return {
+		status: "expired",
+		expiredAt: new Date(args.transcriptPurgedAtMs).toISOString()
+	};
+	return args.canExposePayload ? { status: "available" } : {
+		status: "redacted",
+		reason: "non_public_conversation"
 	};
 }
-/** Rebuild the web Actor from durable Conversation identity. */
-function webActorFromEmail(email, profile) {
-	const normalized = normalizeEmail(email);
+/** Project one durable conversation and its SQL metrics into the REST summary. */
+function conversationSummaryFromStoredConversation(args) {
+	const { conversation, durationMs, usage } = args;
+	const canViewPrivateContent = args.access?.canViewPrivateContent ?? false;
+	const accessVisibility = args.access?.visibility;
+	const visibility = accessVisibility === "public" || accessVisibility === "private" ? accessVisibility : void 0;
+	const surface = surfaceFromSource(conversation.source, conversation.conversationId);
+	const actorIdentity = actorIdentityReport(conversation.actor);
+	const locationUrl = locationUrlFromConversation({
+		canViewPrivateContent,
+		conversation,
+		...args.teamDomainByTeamId ? { teamDomainByTeamId: args.teamDomainByTeamId } : void 0
+	});
+	const slackThread = parseSlackThreadId(conversation.conversationId);
+	const channelName = channelNameFromConversation(conversation, canViewPrivateContent, visibility);
+	const channelNameRedacted = channelNameRedactedFromConversation(conversation, canViewPrivateContent);
 	return {
-		platform: "web",
-		userId: `dashboard:${stableHex(normalized)}`,
-		email: normalized,
-		...profile?.fullName ? { fullName: profile.fullName } : void 0,
-		...profile?.userName ? { userName: profile.userName } : void 0
+		conversationId: conversation.conversationId,
+		cumulativeDurationMs: durationMs,
+		displayTitle: titleFromConversation({
+			automationTitle: args.automationTitle,
+			canViewPrivateContent,
+			conversation,
+			firstHumanMessageText: args.firstHumanMessageText,
+			surface,
+			visibility
+		}),
+		isParticipant: args.access?.isParticipant ?? false,
+		...visibility ? { visibility } : void 0,
+		lastProgressAt: new Date(conversation.execution.updatedAtMs ?? conversation.updatedAtMs).toISOString(),
+		lastSeenAt: new Date(conversation.lastActivityAtMs).toISOString(),
+		startedAt: new Date(conversation.createdAtMs).toISOString(),
+		status: statusFromConversation(conversation),
+		surface,
+		...args.auxiliaryCosts ? { auxiliaryCosts: args.auxiliaryCosts } : void 0,
+		...usage ? { cumulativeUsage: usage } : void 0,
+		...args.childAgentTotals ? { childAgentTotals: args.childAgentTotals } : void 0,
+		...actorIdentity ? { actorIdentity } : void 0,
+		...locationUrl ? { locationUrl } : void 0,
+		archivedAt: args.archivedAtMs === void 0 ? null : new Date(args.archivedAtMs).toISOString(),
+		...slackThread ? { channel: slackThread.channelId } : void 0,
+		...channelName ? { channelName } : void 0,
+		...channelNameRedacted ? { channelNameRedacted: true } : void 0,
+		...args.locationId && !channelNameRedacted ? { locationId: args.locationId } : 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();
+// src/api/conversations/usage.ts
+const usage = juniorConversations.usage;
+const componentFields = [
+	"inputTokens",
+	"outputTokens",
+	"cachedInputTokens",
+	"cacheCreationTokens"
+];
+function summedUsageNumber(field) {
+	return sql`sum((${usage}->>${field})::double precision)::double precision`;
+}
+function summedCostNumber(field) {
+	return sql`round(
+    sum((${usage}->'cost'->>${field})::numeric),
+    12
+  )::double precision`;
+}
+function usageFromAggregate(row) {
+	const components = {};
+	let componentTotal = 0;
+	for (const field of componentFields) {
+		const value = row[field];
+		if (value === null) continue;
+		components[field] = value;
+		componentTotal += value;
+	}
+	const cost = {
+		...row.costInput === null ? void 0 : { input: row.costInput },
+		...row.costOutput === null ? void 0 : { output: row.costOutput },
+		...row.costCacheRead === null ? void 0 : { cacheRead: row.costCacheRead },
+		...row.costCacheWrite === null ? void 0 : { cacheWrite: row.costCacheWrite },
+		...row.costTotal === null ? void 0 : { total: row.costTotal }
+	};
+	const result = {
+		...row.totalOnlyTokens === null ? components : { totalTokens: row.totalOnlyTokens + componentTotal },
+		...row.reasoningTokens === null ? void 0 : { reasoningTokens: row.reasoningTokens },
+		...Object.keys(cost).length === 0 ? void 0 : { cost }
+	};
+	return hasAgentTurnUsage(result) ? result : void 0;
+}
+/**
+* Aggregate saved runtime and usage in PostgreSQL. The total for each selected
+* Conversation includes itself and all its child agents at any depth.
+*/
+async function readConversationTreeMetricsFromSql(db, conversationIds) {
+	if (conversationIds.length === 0) return /* @__PURE__ */ new Map();
+	const hasComponents = sql`coalesce(
+    ${usage}->>'inputTokens',
+    ${usage}->>'outputTokens',
+    ${usage}->>'cachedInputTokens',
+    ${usage}->>'cacheCreationTokens'
+  ) is not null`;
+	const isChildAgent = sql`(${conversationSubtreeColumns.conversationId} <> ${conversationSubtreeColumns.scopeConversationId})`;
+	const rows = await db.select({
+		scopeConversationId: conversationSubtreeColumns.scopeConversationId,
+		isChildAgent,
+		conversations: sql`count(*)::integer`.mapWith(Number),
+		durationMs: sql`coalesce(sum(${juniorConversations.durationMs}), 0)::double precision`,
+		inputTokens: summedUsageNumber("inputTokens"),
+		outputTokens: summedUsageNumber("outputTokens"),
+		cachedInputTokens: summedUsageNumber("cachedInputTokens"),
+		cacheCreationTokens: summedUsageNumber("cacheCreationTokens"),
+		totalOnlyTokens: sql`sum(
+        case
+          when not (${hasComponents})
+          then (${usage}->>'totalTokens')::double precision
+        end
+      )::double precision`,
+		reasoningTokens: summedUsageNumber("reasoningTokens"),
+		costInput: summedCostNumber("input"),
+		costOutput: summedCostNumber("output"),
+		costCacheRead: summedCostNumber("cacheRead"),
+		costCacheWrite: summedCostNumber("cacheWrite"),
+		costTotal: summedCostNumber("total")
+	}).from(juniorConversations).innerJoin(conversationSubtree(conversationIds), eq(conversationSubtreeColumns.conversationId, juniorConversations.conversationId)).groupBy(conversationSubtreeColumns.scopeConversationId, isChildAgent);
+	const ownRows = /* @__PURE__ */ new Map();
+	const childRows = /* @__PURE__ */ new Map();
+	for (const row of rows) (row.isChildAgent ? childRows : ownRows).set(row.scopeConversationId, row);
+	const result = /* @__PURE__ */ new Map();
+	for (const [conversationId, own] of ownRows) {
+		const ownUsage = usageFromAggregate(own);
+		const child = childRows.get(conversationId);
+		const childUsage = child ? usageFromAggregate(child) : void 0;
+		const usage = addAgentTurnUsage(ownUsage, childUsage);
+		result.set(conversationId, {
+			durationMs: own.durationMs + (child?.durationMs ?? 0),
+			...usage ? { usage } : void 0,
+			...child ? { childAgents: {
+				count: child.conversations,
+				durationMs: child.durationMs,
+				...childUsage ? { usage: childUsage } : void 0
+			} } : void 0
+		});
+	}
+	return result;
+}
+/**
+* Project the child agent part of tree metrics into the API shape. Return
+* nothing when the Conversation has no child agents.
+*/
+function childAgentTotalsReport(metrics, auxiliaryCosts) {
+	const childAgents = metrics?.childAgents;
+	if (!childAgents) return void 0;
 	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"
+		...auxiliaryCosts?.childAgentCostUsd === void 0 ? void 0 : { auxiliaryCostUsd: auxiliaryCosts.childAgentCostUsd },
+		count: childAgents.count,
+		cumulativeDurationMs: childAgents.durationMs,
+		...childAgents.usage ? { cumulativeUsage: childAgents.usage } : void 0
 	};
 }
-/** 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;
+// src/chat/conversations/fork.ts
+/** Event key of the agent note that follows the copied events in a fork. */
+const FORK_NOTE_KEY = "fork:note";
+const forkNote = alias(juniorConversationEvents, "fork_note");
+/**
+* SQL filter for event rows that a fork did not copy from its source. Usage
+* and cost reports use it, so copied model calls count only in the source.
+*/
+function notCopiedByFork() {
+	return sql`not exists (
+    select 1 from ${juniorConversationEvents} as ${sql.identifier("fork_note")}
+    where ${forkNote.conversationId} = ${juniorConversationEvents.conversationId}
+      and ${forkNote.idempotencyKey} = ${FORK_NOTE_KEY}
+      and ${forkNote.seq} > ${juniorConversationEvents.seq}
+  )`;
 }
-/** 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");
+/**
+* Events that hold credentials, approvals, provider connections, or plugin
+* state of the source actor. A fork does not copy them.
+*/
+const UNCOPIED_EVENT_TYPES = /* @__PURE__ */ new Set([
+	"authorization_completed",
+	"authorization_requested",
+	"guardian_action_reviewed",
+	"mcp_provider_connected",
+	"mcp_provider_connected_unowned",
+	"structured_event",
+	"unknown"
+]);
+const FORK_NOTE = "This Conversation is a fork. The earlier messages are copied from another Conversation. Sandbox files, active work, approvals, credentials, Watches, Automations, and the delivery location were not copied. Earlier file paths and runtime context belong to the source Conversation. Verify files in the current Sandbox before you use them.";
+/** An expected fork request failure, such as a reply without saved history. */
+var ConversationForkError = class extends Error {};
+/**
+* Create a new web root Conversation from the agent history of a source
+* Conversation, through one completed assistant reply.
+*
+* Retries with the same requester and key return the same Conversation.
+*/
+async function forkConversation(input) {
 	const conversationId = createConversationId({
-		actorEmail: input.actor.email,
-		idempotencyKey: input.idempotencyKey
+		actorEmail: input.actorEmail,
+		idempotencyKey: JSON.stringify([
+			"fork",
+			input.sourceConversationId,
+			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);
+	const executor = getSqlExecutor();
+	const events = getConversationEventStore();
+	const store = getConversationStore();
+	return withConversationEventLock(executor, input.sourceConversationId, () => withConversationEventLock(executor, conversationId, async () => {
+		if (await store.get({ conversationId })) return { conversationId };
+		const source = await store.get({ conversationId: input.sourceConversationId });
+		if (!source || source.transcriptPurgedAtMs !== void 0) throw new ConversationForkError("The source history is no longer available.");
+		if (source.parentConversationId) throw new ConversationForkError("You cannot fork a child conversation.");
+		const boundary = await events.loadByIdempotencyKey(input.sourceConversationId, `message:${input.messageId}:agent`);
+		const reply = boundary?.data.type === "assistant_message" ? piMessageFromHistoryItem(boundary.data) : void 0;
+		if (!boundary || reply?.role !== "assistant" || reply.stopReason !== "stop" || reply.content.some((part) => part.type === "toolCall")) throw new ConversationForkError("Choose a completed assistant reply with saved agent history.");
+		const projection = await loadTurnProjection({
+			conversationId: input.sourceConversationId,
+			committedSeq: boundary.seq,
+			includeTail: false
+		});
+		if (!projection?.messages.length) throw new ConversationForkError("The selected history is no longer available.");
+		if (hasUnfinishedToolCalls(projection.messages)) throw new ConversationForkError("This history has unfinished tool calls. Choose another reply.");
+		const nowMs = Date.now();
+		await recordWebConversationActivity({
+			actor: webActorFromEmail(input.actorEmail, { ...input.actorName ? { fullName: input.actorName } : void 0 }),
+			conversationId,
+			nowMs,
+			rootVisibility: source.visibility === "public" ? "public" : "private"
+		});
+		await executor.db().update(juniorConversations).set({
+			forkedFromConversationId: source.conversationId,
+			title: source.title ? `Fork: ${source.title}` : "Forked conversation"
+		}).where(eq(juniorConversations.conversationId, conversationId));
+		await copyForkEvents({
+			sourceConversationId: source.conversationId,
+			conversationId,
+			events: await events.loadHistory(source.conversationId),
+			boundarySeq: boundary.seq,
+			messageId: input.messageId
+		});
+		await events.append(conversationId, [{
+			idempotencyKey: FORK_NOTE_KEY,
+			createdAtMs: nowMs,
+			data: {
+				type: "user_message",
+				provenance: contextProvenance,
+				content: [{
+					type: "text",
+					text: FORK_NOTE
+				}],
+				timestamp: nowMs
+			}
+		}]);
+		return { conversationId };
+	}));
 }
-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
+/**
+* Copy the source event rows through the selected reply. Copies keep their
+* sequence, author, timestamp, key, and payload, so the fork shows the same
+* transcript and event log, and seq references in compactions stay valid.
+* Later updates of copied Messages and the end of copied Turns are also
+* copied, so that no copied item stays open in the fork.
+*/
+async function copyForkEvents(args) {
+	const reply = args.events.find((event) => event.data.type === "message" && event.data.role === "assistant" && event.data.messageId === args.messageId);
+	const cutoffSeq = Math.max(args.boundarySeq, reply?.seq ?? -1);
+	const messageIds = /* @__PURE__ */ new Set();
+	const turnIds = /* @__PURE__ */ new Set();
+	const seqs = [];
+	let historyVersion = 0;
+	for (const event of args.events) {
+		const data = event.data;
+		if (UNCOPIED_EVENT_TYPES.has(data.type)) continue;
+		if (event.idempotencyKey === FORK_NOTE_KEY) continue;
+		if (event.seq <= cutoffSeq) {
+			if (data.type === "message") messageIds.add(data.messageId);
+			if (data.type === "turn_started") turnIds.add(data.turnId);
+			historyVersion = Math.max(historyVersion, event.historyVersion);
+			seqs.push(event.seq);
+		} else if ((data.type === "message_updated" || data.type === "message_handled") && messageIds.has(data.messageId) || (data.type === "turn_completed" || data.type === "turn_failed") && turnIds.has(data.turnId)) seqs.push(event.seq);
+	}
+	if (!seqs.length) return;
+	const e = juniorConversationEvents;
+	await getSqlExecutor().db().execute(sql`insert into ${e} (${sql.join([
+		e.conversationId,
+		e.seq,
+		e.historyVersion,
+		e.schemaVersion,
+		e.idempotencyKey,
+		e.type,
+		e.payload,
+		e.actorIdentityId,
+		e.createdAt
+	].map((column) => sql.identifier(column.name)), sql`, `)})
+      select ${args.conversationId}, ${e.seq}, least(${e.historyVersion}, ${historyVersion}), ${e.schemaVersion}, ${e.idempotencyKey}, ${e.type}, ${e.payload}, ${e.actorIdentityId}, ${e.createdAt}
+      from ${e}
+      where ${e.conversationId} = ${args.sourceConversationId}
+        and ${inArray(e.seq, seqs)}`);
+}
+function hasUnfinishedToolCalls(messages) {
+	const pending = /* @__PURE__ */ new Set();
+	for (const message of messages) if (message.role === "assistant") {
+		for (const part of message.content) if (part.type === "toolCall") pending.add(part.id);
+	} else if (message.role === "toolResult") pending.delete(message.toolCallId);
+	return pending.size > 0;
+}
+// src/api/conversations/auxiliary-costs.ts
+function eventCost() {
+	return sql`CASE
+    WHEN ${juniorConversationEvents.type} = 'structured_event'
+      AND jsonb_typeof(${juniorConversationEvents.payload}->'content'->'costUsd') = 'number'
+      THEN (${juniorConversationEvents.payload}->'content'->>'costUsd')::numeric
+    WHEN ${juniorConversationEvents.type} IN ('guardian_action_reviewed', 'turn_routed')
+      AND jsonb_typeof(${juniorConversationEvents.payload}->'costUsd') = 'number'
+      THEN (${juniorConversationEvents.payload}->>'costUsd')::numeric
+    ELSE NULL
+  END`;
+}
+function addCostUsd(left, right) {
+	return Math.round((left + right) * 0xe8d4a51000) / 0xe8d4a51000;
+}
+/**
+* Aggregate additive event costs by namespaced operation. The total for each
+* selected Conversation includes itself and all its child agents at any depth.
+*/
+async function readConversationAuxiliaryCostsFromSql(db, conversationIds) {
+	if (conversationIds.length === 0) return /* @__PURE__ */ new Map();
+	const scopeConversationId = conversationSubtreeColumns.scopeConversationId;
+	const isChildAgent = sql`(${conversationSubtreeColumns.conversationId} <> ${scopeConversationId})`;
+	const namespace = sql`CASE
+    WHEN ${juniorConversationEvents.type} = 'structured_event'
+      THEN ${juniorConversationEvents.payload}->>'namespace'
+    ELSE 'junior'
+  END`;
+	const name = sql`CASE
+    WHEN ${juniorConversationEvents.type} = 'structured_event'
+      THEN ${juniorConversationEvents.payload}->>'name'
+    ELSE ${juniorConversationEvents.type}
+  END`;
+	const cost = eventCost();
+	const rows = await db.select({
+		conversationId: scopeConversationId,
+		childAgentCostUsd: sql`coalesce(round(sum(case when ${isChildAgent} then ${cost} end), 12), 0)::double precision`.mapWith(Number),
+		costUsd: sql`round(sum(${cost}), 12)::double precision`.mapWith(Number),
+		events: sql`count(*)::integer`.mapWith(Number),
+		name,
+		namespace
+	}).from(juniorConversationEvents).innerJoin(conversationSubtree(conversationIds), eq(conversationSubtreeColumns.conversationId, juniorConversationEvents.conversationId)).where(and(or(eq(juniorConversationEvents.type, "structured_event"), inArray(juniorConversationEvents.type, ["guardian_action_reviewed", "turn_routed"])), sql`${cost} >= 0`, notCopiedByFork())).groupBy(scopeConversationId, namespace, name).orderBy(scopeConversationId, namespace, name);
+	const result = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const current = result.get(row.conversationId) ?? { total: {
+			costUsd: 0,
+			operations: []
+		} };
+		current.total.costUsd = addCostUsd(current.total.costUsd, row.costUsd);
+		if (row.childAgentCostUsd > 0) current.childAgentCostUsd = addCostUsd(current.childAgentCostUsd ?? 0, row.childAgentCostUsd);
+		current.total.operations.push({
+			costUsd: row.costUsd,
+			events: row.events,
+			name: row.name,
+			namespace: row.namespace
+		});
+		result.set(row.conversationId, current);
+	}
+	return result;
+}
+// src/chat/plugins/conversation-sidebar.ts
+/** Show native objects by default and let plugins select compact sidebar labels. */
+async function listConversationSidebarAnnotations(conversationIds, annotationsByConversation) {
+	const candidates = new Set(conversationIds);
+	const selected = {};
+	const plugins = getPlugins();
+	const customOwners = new Set(plugins.filter((plugin) => plugin.hooks?.conversationSidebar).map((plugin) => plugin.manifest.name));
+	for (const conversationId of conversationIds) {
+		const objects = (annotationsByConversation.get(conversationId) ?? []).flatMap((annotation) => {
+			if (customOwners.has(annotation.plugin) || !annotation.objectType) return [];
+			return [{
+				key: annotation.key,
+				label: annotation.label,
+				objectType: annotation.objectType === "item" && annotation.kind === "object" && annotation.facts?.type === "deployment" ? "deployment" : annotation.objectType,
+				status: annotation.status
+			}];
+		});
+		if (objects.length) selected[conversationId] = objects;
+	}
+	for (const plugin of plugins) {
+		const hook = plugin.hooks?.conversationSidebar;
+		if (!hook) continue;
+		const annotationsByConversationId = Object.fromEntries(conversationIds.flatMap((conversationId) => {
+			const annotations = (annotationsByConversation.get(conversationId) ?? []).filter((annotation) => annotation.plugin === plugin.manifest.name);
+			return annotations.length > 0 ? [[conversationId, annotations]] : [];
+		}));
+		try {
+			const result = await hook({
+				annotationsByConversationId,
+				conversationIds,
+				db: getDb(),
+				log: createPluginLogger(plugin.manifest.name),
+				plugin: { name: plugin.manifest.name },
+				cache: createPluginCache(plugin.manifest.name)
+			});
+			for (const [conversationId, annotations] of Object.entries(result.annotationsByConversationId)) {
+				if (!candidates.has(conversationId)) continue;
+				const parsed = conversationSidebarAnnotationSchema.array().safeParse(annotations);
+				if (!parsed.success || parsed.data.length === 0) continue;
+				selected[conversationId] = [...selected[conversationId] ?? [], ...parsed.data];
+			}
+		} catch (error) {
+			logWarn("plugin.conversation_sidebar.hook.failed", {
+				"app.plugin.name": plugin.manifest.name,
+				"exception.message": error instanceof Error ? error.message : String(error)
+			});
+		}
+	}
+	return selected;
+}
+// src/chat/plugins/unfinished-work.ts
+/**
+* Return assigned and unfinished plugin work for the candidate conversations.
+* Feed Priority combines these signals with conversation activity on the host.
+*/
+async function listConversationWork(conversationIds) {
+	if (conversationIds.length === 0) return {
+		assignedIds: [],
+		finishedAtById: {},
+		unfinishedIds: []
+	};
+	const candidates = new Set(conversationIds);
+	const assigned = /* @__PURE__ */ new Set();
+	const finishedAtById = /* @__PURE__ */ new Map();
+	const unfinished = /* @__PURE__ */ new Set();
+	for (const plugin of getPlugins()) {
+		const hook = plugin.hooks?.unfinishedWork;
+		if (!hook) continue;
+		try {
+			const result = await hook({
+				conversationIds,
+				db: getDb(),
+				log: createPluginLogger(plugin.manifest.name),
+				plugin: { name: plugin.manifest.name },
+				cache: createPluginCache(plugin.manifest.name)
+			});
+			for (const conversationId of result.conversationIds) {
+				if (!candidates.has(conversationId)) continue;
+				unfinished.add(conversationId);
+				assigned.add(conversationId);
+			}
+			for (const conversationId of result.assignedConversationIds ?? []) if (candidates.has(conversationId)) assigned.add(conversationId);
+			for (const [conversationId, finishedAt] of Object.entries(result.finishedWorkAtByConversationId ?? {})) {
+				if (!candidates.has(conversationId)) continue;
+				const time = Date.parse(finishedAt);
+				if (!Number.isFinite(time)) continue;
+				const current = finishedAtById.get(conversationId);
+				if (!current || time > Date.parse(current)) finishedAtById.set(conversationId, finishedAt);
+			}
+		} catch (error) {
+			logWarn("plugin.unfinished_work.hook.failed", {
+				"app.plugin.name": plugin.manifest.name,
+				"exception.message": error instanceof Error ? error.message : String(error)
+			});
+		}
+	}
+	return {
+		assignedIds: conversationIds.filter((conversationId) => assigned.has(conversationId)),
+		finishedAtById: Object.fromEntries(conversationIds.flatMap((conversationId) => {
+			const finishedAt = finishedAtById.get(conversationId);
+			return finishedAt ? [[conversationId, finishedAt]] : [];
+		})),
+		unfinishedIds: conversationIds.filter((conversationId) => unfinished.has(conversationId))
+	};
+}
+// src/api/conversations/priority.ts
+/** Conversations with no known work leave Priority after this idle window. */
+const UNASSIGNED_PRIORITY_WINDOW_MS = 108e5;
+/** Unfinished work leaves Priority after this idle window. */
+const UNFINISHED_PRIORITY_WINDOW_MS = 1728e5;
+/**
+* Decide whether a conversation belongs in the dashboard Priority section.
+*
+* Priority includes only:
+* - unfinished work last seen within 48 hours
+* - finished assigned work with a user message after the finish time
+* - no known work last seen within 3 hours
+*
+* Finished assigned work with no later activity stays out of Priority.
+*/
+function isConversationPriority(conversation, nowMs) {
+	const lastSeenAt = Date.parse(conversation.lastSeenAt);
+	if (!Number.isFinite(lastSeenAt)) return false;
+	if (conversation.unfinishedWork) return nowMs - lastSeenAt <= UNFINISHED_PRIORITY_WINDOW_MS;
+	if (conversation.assignedWork) {
+		const finishedAt = Date.parse(conversation.finishedWorkAt ?? "");
+		const lastUserMessageAt = Date.parse(conversation.lastUserMessageAt ?? "");
+		return Number.isFinite(finishedAt) && Number.isFinite(lastUserMessageAt) && lastUserMessageAt > finishedAt;
+	}
+	return nowMs - lastSeenAt <= UNASSIGNED_PRIORITY_WINDOW_MS;
+}
+// src/api/conversations/user-message-activity.ts
+/** Read the latest true user message time for each selected conversation. */
+async function readLastUserMessageAtByConversation(db, conversationIds) {
+	if (conversationIds.length === 0) return /* @__PURE__ */ new Map();
+	const authority = sql`${juniorConversationEvents.payload}->'provenance'->>'authority'`;
+	const actorPlatform = sql`${juniorConversationEvents.payload}->'provenance'->'actor'->>'platform'`;
+	const role = sql`${juniorConversationEvents.payload}->>'role'`;
+	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);
+	return new Map(rows.map((row) => [row.conversationId, new Date(row.lastUserMessageAt).toISOString()]));
+}
+// src/api/conversations/activity-preview.ts
+/** Read one recent assistant message, or the latest user message, for each conversation. */
+async function readConversationActivityPreviews(db, conversationIds) {
+	if (conversationIds.length === 0) return /* @__PURE__ */ new Map();
+	const role = sql`${juniorConversationEvents.payload}->>'role'`;
+	const text = sql`${juniorConversationEvents.payload}->>'text'`;
+	const assistantFirst = sql`case when ${role} = 'assistant' then 0 else 1 end`;
+	const rows = await db.selectDistinctOn([juniorConversationEvents.conversationId], {
+		conversationId: juniorConversationEvents.conversationId,
+		createdAt: juniorConversationEvents.createdAt,
+		role: role.as("role"),
+		text: text.as("text")
+	}).from(juniorConversationEvents).where(and(inArray(juniorConversationEvents.conversationId, conversationIds), eq(juniorConversationEvents.type, "message"), sql`${role} in ('assistant', 'user')`, isNotNull(sql`nullif(btrim(${text}), '')`))).orderBy(juniorConversationEvents.conversationId, assistantFirst, desc(juniorConversationEvents.createdAt), desc(juniorConversationEvents.seq));
+	return new Map(rows.map((row) => [row.conversationId, {
+		createdAt: row.createdAt.toISOString(),
+		role: row.role,
+		text: row.text
+	}]));
+}
+// src/api/conversations/first-message.ts
+/**
+* Read the text of the first human message for each untitled conversation.
+* Read-time titles use it while the generated title is still unset.
+*/
+async function readFirstHumanMessageTexts(db, conversations) {
+	const untitledIds = conversations.flatMap((conversation) => conversation.title ? [] : [conversation.conversationId]);
+	if (untitledIds.length === 0) return /* @__PURE__ */ new Map();
+	const text = sql`${juniorConversationEvents.payload}->>'text'`;
+	const rows = await db.selectDistinctOn([juniorConversationEvents.conversationId], {
+		conversationId: juniorConversationEvents.conversationId,
+		text: text.as("text")
+	}).from(juniorConversationEvents).where(and(inArray(juniorConversationEvents.conversationId, untitledIds), eq(juniorConversationEvents.type, "message"), sql`${juniorConversationEvents.payload}->>'role' = 'user'`, sql`coalesce(${juniorConversationEvents.payload}->'meta'->'author'->>'isBot', 'false') <> 'true'`, isNotNull(sql`nullif(btrim(${text}), '')`))).orderBy(juniorConversationEvents.conversationId, asc(juniorConversationEvents.createdAt), asc(juniorConversationEvents.seq));
+	return new Map(rows.map((row) => [row.conversationId, row.text]));
+}
+// src/api/mentions.ts
+const SLACK_USER_MENTION_RE = /<@([UW][A-Z0-9]+)(?:\|[^<>]*)?>/g;
+function mentionedSlackUserIds(texts) {
+	const ids = texts.flatMap((text) => text ? [...text.matchAll(SLACK_USER_MENTION_RE)].map((m) => m[1]) : []);
+	return [...new Set(ids)];
+}
+/**
+* Resolve the people that each source mentions, in source order. Every API
+* that returns display text uses this, so the dashboard can show the same
+* names and People links everywhere. It does one identity query per Slack
+* workspace.
+*/
+async function resolveMentions(executor, sources) {
+	const idsBySource = sources.map((source) => mentionedSlackUserIds(source.texts));
+	const idsByTenant = /* @__PURE__ */ new Map();
+	sources.forEach((source, index) => {
+		if (idsBySource[index].length === 0) return;
+		const ids = idsByTenant.get(source.tenantId) ?? /* @__PURE__ */ new Set();
+		for (const id of idsBySource[index]) ids.add(id);
+		idsByTenant.set(source.tenantId, ids);
 	});
-	const destination = await recordWebConversationActivity({
-		actor: input.actor,
-		conversationId: input.conversationId,
-		conversationStore: options.conversationStore,
-		nowMs,
-		...input.rootVisibility && { rootVisibility: input.rootVisibility }
+	const peopleByTenant = new Map(await Promise.all([...idsByTenant].map(async ([tenantId, ids]) => [tenantId, await readMentionedPeople(executor, tenantId, [...ids])])));
+	return sources.map((source, index) => {
+		const people = peopleByTenant.get(source.tenantId);
+		return idsBySource[index].flatMap((id) => {
+			const person = people?.get(id);
+			return person ? [person] : [];
+		});
 	});
-	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
+}
+/**
+* Read current names for mentioned Slack users. Known Junior identities come
+* first. The email is set only for a linked, verified Junior user, because
+* that email is the People profile route.
+*/
+async function readMentionedPeople(executor, tenantId, userIds) {
+	const rows = await executor.db().select({
+		displayName: juniorIdentities.displayName,
+		emailVerified: juniorIdentities.emailVerified,
+		handle: juniorIdentities.handle,
+		providerSubjectId: juniorIdentities.providerSubjectId,
+		userDisplayName: juniorUsers.displayName,
+		userEmail: juniorUsers.primaryEmail
+	}).from(juniorIdentities).leftJoin(juniorUsers, eq(juniorUsers.id, juniorIdentities.userId)).where(and(eq(juniorIdentities.provider, "slack"), inArray(juniorIdentities.providerSubjectId, userIds), tenantId ? eq(juniorIdentities.providerTenantId, tenantId) : void 0));
+	const people = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		if (people.has(row.providerSubjectId)) continue;
+		const fullName = row.userDisplayName?.trim() || row.displayName?.trim();
+		const email = row.emailVerified ? row.userEmail?.trim() : void 0;
+		people.set(row.providerSubjectId, {
+			slackUserId: row.providerSubjectId,
+			...fullName ? { fullName } : void 0,
+			...row.handle ? { slackUserName: row.handle } : void 0,
+			...email ? { email } : void 0
 		});
 	}
-	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 unnamed = userIds.filter((id) => {
+		const person = people.get(id);
+		return !person?.fullName && !person?.slackUserName;
+	});
+	if (tenantId && unnamed.length > 0) {
+		const profiles = await Promise.all(unnamed.map((id) => lookupSlackUser(tenantId, id)));
+		unnamed.forEach((id, index) => {
+			const profile = profiles[index];
+			if (!profile?.fullName && !profile?.userName) return;
+			people.set(id, {
+				...people.get(id),
+				slackUserId: id,
+				...profile.fullName ? { fullName: profile.fullName } : void 0,
+				...profile.userName ? { slackUserName: profile.userName } : void 0
+			});
+		});
+	}
+	return people;
+}
+// src/api/conversations/mentions.ts
+/** Text in one event that the dashboard renders with mentions. */
+function eventMentionTexts(data) {
+	switch (data.type) {
+		case "message": return data.redacted ? [] : [
+			data.text,
+			data.trustedSummary,
+			...(data.events ?? []).map((event) => event.trustedSummary)
+		];
+		case "assistant_message": return data.parts.map((part) => part.text);
+		case "compaction":
+		case "handoff": return [data.summary];
+		case "structured_event": return [data.presentation.preview, ...(data.presentation.details ?? []).map((detail) => detail.description)];
+		default: return [];
+	}
+}
+function briefMentionTexts(brief) {
+	return [
+		brief.summary,
+		brief.intent,
+		brief.outcome.text,
+		...brief.decisions.flatMap((decision) => [decision.text, decision.by]),
+		...brief.openDecisions.flatMap((decision) => [decision.text, decision.owner]),
+		...brief.facts
+	];
+}
+function withMentions(value, mentions) {
+	return mentions.length > 0 ? {
+		...value,
+		mentions
+	} : value;
+}
+/**
+* Attach the people that each event and the Brief of one conversation
+* mention, resolved at read time.
+*/
+async function attachConversationMentions(executor, conversationId, content) {
+	const tenantId = (await loadConversationSlackTenantIds(executor, [conversationId])).get(conversationId);
+	const sources = content.events.map((event) => ({
+		tenantId,
+		texts: eventMentionTexts(event.data)
+	}));
+	if (content.brief) sources.push({
+		tenantId,
+		texts: briefMentionTexts(content.brief)
 	});
-	const status = result.status === "appended" ? "accepted" : result.status;
+	const mentions = await resolveMentions(executor, sources);
+	return {
+		briefMentions: content.brief ? mentions.at(-1) : [],
+		events: content.events.map((event, index) => withMentions(event, mentions[index]))
+	};
+}
+/** Attach the people that each activity preview mentions, resolved at read time. */
+async function attachActivityPreviewMentions(executor, previews) {
+	const entries = [...previews];
+	const tenants = await loadConversationSlackTenantIds(executor, entries.map(([conversationId]) => conversationId));
+	const mentions = await resolveMentions(executor, entries.map(([conversationId, preview]) => ({
+		tenantId: tenants.get(conversationId),
+		texts: [preview.text]
+	})));
+	return new Map(entries.map(([conversationId, preview], index) => [conversationId, withMentions(preview, mentions[index])]));
+}
+// src/api/conversations/participants.ts
+const identityColumns = {
+	displayName: juniorIdentities.displayName,
+	email: juniorIdentities.email,
+	handle: juniorIdentities.handle,
+	identityId: juniorIdentities.id,
+	provider: juniorIdentities.provider,
+	providerSubjectId: juniorIdentities.providerSubjectId,
+	userDisplayName: juniorUsers.displayName,
+	userEmail: juniorUsers.primaryEmail,
+	userId: juniorIdentities.userId
+};
+function participantIdentity(row) {
+	const fullName = row.userDisplayName?.trim() || row.displayName?.trim();
+	const email = row.email?.trim() || row.userEmail?.trim();
+	const slack = row.provider === "slack";
+	const participant = {
+		...email ? { email } : void 0,
+		...fullName ? { fullName } : void 0,
+		...slack && row.providerSubjectId ? { slackUserId: row.providerSubjectId } : void 0,
+		...slack && row.handle ? { slackUserName: row.handle } : void 0
+	};
+	return Object.keys(participant).length > 0 ? participant : void 0;
+}
+/** Read actor identities in first-appearance order for each Conversation. */
+async function readConversationParticipants(db, conversationIds) {
+	if (conversationIds.length === 0) return /* @__PURE__ */ new Map();
+	const [rootRows, eventRows] = await Promise.all([db.select({
+		conversationId: juniorConversations.conversationId,
+		...identityColumns
+	}).from(juniorConversations).innerJoin(juniorIdentities, eq(juniorIdentities.id, juniorConversations.actorIdentityId)).leftJoin(juniorUsers, eq(juniorUsers.id, juniorIdentities.userId)).where(inArray(juniorConversations.conversationId, [...conversationIds])), db.selectDistinctOn([juniorConversationEvents.conversationId, juniorConversationEvents.actorIdentityId], {
+		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))]);
+	const ordered = /* @__PURE__ */ new Map();
+	const add = (conversationId, row) => {
+		const participant = participantIdentity(row);
+		if (!participant) return;
+		const group = ordered.get(conversationId) ?? {
+			identities: [],
+			keys: /* @__PURE__ */ new Set()
+		};
+		const key = row.userId ? `user:${row.userId}` : `identity:${row.identityId}`;
+		if (!group.keys.has(key)) {
+			group.keys.add(key);
+			group.identities.push(participant);
+		}
+		ordered.set(conversationId, group);
+	};
+	for (const row of rootRows) add(row.conversationId, row);
+	for (const row of eventRows.sort((left, right) => left.seq - right.seq)) add(row.conversationId, row);
+	return new Map([...ordered].map(([conversationId, group]) => [conversationId, group.identities]));
+}
+// src/api/conversations/list.ts
+const CONVERSATION_FEED_LIMIT = 50;
+function conversationFeedMembershipFilter(status, filter) {
+	if (!filter) return status === "archived" ? sql`false` : void 0;
+	if (filter.kind === "viewer") return and(conversationIsMemberRoot({ userId: filter.userId }), status === "archived" ? conversationArchivedForUser(filter.userId) : status === "all" ? void 0 : conversationNotArchivedForUser(filter.userId));
+	return and(conversationIsMemberRoot({ email: filter.email }), status === "archived" ? conversationArchivedForEmail(filter.email) : status === "all" ? void 0 : conversationNotArchivedForEmail(filter.email));
+}
+/**
+* Keep root conversations linked to one code repository. A code change can
+* link a child conversation, so linked ids resolve to their root. Private
+* roots stay visible only to their members.
+*/
+function conversationCodeRepositoryFilter(repositoryId, viewerUserId) {
+	return and(sql`${juniorConversations.conversationId} IN (
+      SELECT coalesce(linked.root_conversation_id, linked.conversation_id)
+      FROM ${juniorConversations} AS linked
+      WHERE linked.conversation_id IN (
+        SELECT unnest(${juniorCodeChanges.conversationIds})
+        FROM ${juniorCodeChanges}
+        WHERE ${juniorCodeChanges.repositoryId} = ${repositoryId}
+      )
+    )`, or(eq(juniorDestinations.visibility, "public"), viewerUserId ? viewerConversationMembership({
+		actorMatch: eq(juniorIdentities.userId, viewerUserId),
+		participantMatch: conversationHasParticipantUser(viewerUserId)
+	}) : void 0));
+}
+async function conversationRows(db, limit, status, filter, query, includePrivateBriefs = false, codeRepository) {
+	return db.select({
+		conversation: conversationReadColumns(),
+		location: juniorDestinations,
+		identityDisplayName: juniorIdentities.displayName,
+		identityEmail: juniorIdentities.email,
+		identityHandle: juniorIdentities.handle,
+		identityProvider: juniorIdentities.provider,
+		identitySubjectId: juniorIdentities.providerSubjectId,
+		identityTenantId: juniorIdentities.providerTenantId,
+		userDisplayName: juniorUsers.displayName
+	}).from(juniorConversations).leftJoin(juniorDestinations, eq(juniorDestinations.id, juniorConversations.destinationId)).leftJoin(juniorIdentities, eq(juniorIdentities.id, juniorConversations.actorIdentityId)).leftJoin(juniorUsers, eq(juniorUsers.id, juniorIdentities.userId)).where(and(isNull(juniorConversations.parentConversationId), conversationFeedMembershipFilter(status, filter), codeRepository ? conversationCodeRepositoryFilter(codeRepository.id, codeRepository.viewerUserId) : void 0, query ? or(sql`strpos(lower(coalesce(${juniorConversations.title}, '')), ${query}) > 0`, sql`exists (
+                select 1
+                from ${juniorConversationBriefs}
+                where ${juniorConversationBriefs.conversationId} = ${juniorConversations.conversationId}
+                  and ${includePrivateBriefs ? sql`true` : eq(juniorDestinations.visibility, "public")}
+                  and ${juniorConversationBriefs.version} = (
+                    select max(${juniorConversationBriefs.version})
+                    from ${juniorConversationBriefs}
+                    where ${juniorConversationBriefs.conversationId} = ${juniorConversations.conversationId}
+                  )
+                  and to_tsvector('english', ${juniorConversationBriefs.searchText})
+                    @@ websearch_to_tsquery('english', ${query})
+              )`) : void 0)).orderBy(desc(juniorConversations.lastActivityAt), asc(juniorConversations.conversationId)).limit(limit);
+}
+/** Decode a conversation row with the linked user name and identity-scoped provider fields. */
+function conversationFromRow(row) {
+	const value = row.conversation;
+	const legacySessionSource = value.sessionSource === null ? void 0 : parseSessionSource(value.sessionSource);
+	if (value.sessionSource !== null && !legacySessionSource) throw new Error("Conversation legacy source_json is invalid");
+	const actorFullName = row.userDisplayName?.trim() ? row.userDisplayName : row.identityDisplayName;
+	const actor = row.identityProvider === "slack" ? {
+		platform: "slack",
+		...row.identityEmail ? { email: row.identityEmail } : void 0,
+		...actorFullName ? { fullName: actorFullName } : void 0,
+		...row.identitySubjectId ? { slackUserId: row.identitySubjectId } : void 0,
+		...row.identityHandle ? { slackUserName: row.identityHandle } : void 0,
+		...row.identityTenantId ? { teamId: row.identityTenantId } : void 0
+	} : void 0;
+	const location = locationFromRow(value.location, row.location, legacySessionSource);
+	return {
+		schemaVersion: 1,
+		conversationId: value.conversationId,
+		createdAtMs: value.createdAt.getTime(),
+		lastActivityAtMs: value.lastActivityAt.getTime(),
+		updatedAtMs: value.updatedAt.getTime(),
+		execution: {
+			status: value.executionStatus,
+			...value.runId ? { runId: value.runId } : void 0,
+			...value.executionUpdatedAt ? { updatedAtMs: value.executionUpdatedAt.getTime() } : void 0
+		},
+		...actor ? { actor } : void 0,
+		...location ? { location } : void 0,
+		...value.channelName ? { channelName: value.channelName } : void 0,
+		...value.source ? { source: value.source } : void 0,
+		...value.title ? { title: value.title } : void 0,
+		...value.transcriptPurgedAt ? { transcriptPurgedAtMs: value.transcriptPurgedAt.getTime() } : void 0
+	};
+}
+/** Read one normalized conversation record directly from its SQL row. */
+async function readConversationRecordFromSql(conversationId) {
+	const row = (await getDb().select({
+		conversation: conversationReadColumns(),
+		location: juniorDestinations,
+		identityDisplayName: juniorIdentities.displayName,
+		identityEmail: juniorIdentities.email,
+		identityHandle: juniorIdentities.handle,
+		identityProvider: juniorIdentities.provider,
+		identitySubjectId: juniorIdentities.providerSubjectId,
+		identityTenantId: juniorIdentities.providerTenantId,
+		userDisplayName: juniorUsers.displayName
+	}).from(juniorConversations).leftJoin(juniorDestinations, eq(juniorDestinations.id, juniorConversations.destinationId)).leftJoin(juniorIdentities, eq(juniorIdentities.id, juniorConversations.actorIdentityId)).leftJoin(juniorUsers, eq(juniorUsers.id, juniorIdentities.userId)).where(eq(juniorConversations.conversationId, conversationId)).limit(1))[0];
+	return row ? {
+		conversation: conversationFromRow(row),
+		durationMs: row.conversation.durationMs,
+		...row.location?.visibility === "public" ? { locationId: row.location.id } : void 0,
+		usage: row.conversation.usage,
+		rootConversationId: row.conversation.rootConversationId
+	} : void 0;
+}
+/** Prefer the authenticated viewer; fall back to actor email membership. */
+function conversationFeedFilter(options) {
+	if (options.viewer) return {
+		kind: "viewer",
+		userId: options.viewer.id
+	};
+	if (options.actorEmail) return {
+		kind: "actorEmail",
+		email: options.actorEmail
+	};
+}
+/**
+* Build a bounded dashboard feed. Prefer the viewer user when present; otherwise
+* keep only roots linked to actorEmail before applying the limit. Membership is
+* root-actor ownership or a materialized participant row for that person.
+*
+* `codeRepositoryId` replaces membership with every root linked to that
+* repository's code changes. Private roots appear only for their members, and
+* per-person archive state does not hide rows.
+*/
+async function readConversationFeedFromSql(options = {}) {
+	const nowMs = Date.now();
+	const db = getDb();
+	const filter = options.codeRepositoryId ? void 0 : conversationFeedFilter(options);
+	const query = options.q?.trim().toLowerCase() || void 0;
+	const rows = await conversationRows(db, options.limit ?? CONVERSATION_FEED_LIMIT, query || options.codeRepositoryId ? "all" : options.status ?? "active", filter, query, filter?.kind === "viewer", options.codeRepositoryId ? {
+		id: options.codeRepositoryId,
+		...options.viewer ? { viewerUserId: options.viewer.id } : void 0
+	} : void 0);
+	const conversations = rows.map((row) => conversationFromRow(row));
+	const conversationIds = conversations.map((conversation) => conversation.conversationId);
+	const [accessByConversation, archiveTimesByConversation, annotationsByConversation, auxiliaryCostsByRoot, metricsByRoot, participantsByConversation, teamDomainByTeamId, conversationWork, lastUserMessageAtByConversation, activityPreviewByConversation, automationTitleByConversation, firstHumanMessageTextByConversation] = await Promise.all([
+		readConversationAccessFromSql(db, conversationIds, options.viewer),
+		conversationArchiveTimes(db, conversationIds, filter?.kind === "viewer" ? { userId: filter.userId } : filter?.kind === "actorEmail" ? { email: filter.email } : void 0),
+		listConversationAnnotationsById(db, conversationIds),
+		readConversationAuxiliaryCostsFromSql(db, conversationIds),
+		readConversationTreeMetricsFromSql(db, conversationIds),
+		readConversationParticipants(db, conversationIds),
+		resolveSlackTeamDomains(conversations.flatMap((conversation) => conversation.location?.provider === "slack" ? [conversation.location.teamId] : [])),
+		listConversationWork(conversationIds),
+		readLastUserMessageAtByConversation(db, conversationIds),
+		readConversationActivityPreviews(db, conversationIds),
+		readAutomationTitlesByConversationId(conversations),
+		readFirstHumanMessageTexts(db, conversations)
+	]);
+	const visibleActivityPreviews = await attachActivityPreviewMentions(getSqlExecutor(), new Map([...activityPreviewByConversation].filter(([conversationId]) => accessByConversation.get(conversationId)?.canViewPrivateContent)));
+	const sidebarAnnotationsByConversation = await listConversationSidebarAnnotations(conversationIds, new Map(conversationIds.map((conversationId) => [conversationId, accessByConversation.get(conversationId)?.canViewPrivateContent ? annotationsByConversation.get(conversationId) ?? [] : []])));
+	const assignedWork = new Set(conversationWork.assignedIds);
+	const unfinishedWork = new Set(conversationWork.unfinishedIds);
 	return {
-		conversationId: input.conversationId,
-		messageId,
-		status
+		conversations: conversations.map((conversation, index) => {
+			const row = rows[index];
+			const access = accessByConversation.get(conversation.conversationId);
+			const metrics = metricsByRoot.get(conversation.conversationId);
+			const auxiliaryCosts = auxiliaryCostsByRoot.get(conversation.conversationId);
+			const childAgentTotals = childAgentTotalsReport(metrics, auxiliaryCosts);
+			const archivedAtMs = archiveTimesByConversation.get(conversation.conversationId);
+			const summary = conversationSummaryFromStoredConversation({
+				...archivedAtMs === void 0 ? void 0 : { archivedAtMs },
+				automationTitle: automationTitleByConversation.get(conversation.conversationId),
+				conversation,
+				access,
+				auxiliaryCosts: auxiliaryCosts?.total,
+				...childAgentTotals ? { childAgentTotals } : void 0,
+				durationMs: metrics?.durationMs ?? row.conversation.durationMs,
+				firstHumanMessageText: firstHumanMessageTextByConversation.get(conversation.conversationId),
+				teamDomainByTeamId,
+				...row.location?.visibility === "public" ? { locationId: row.location.id } : void 0,
+				usage: metrics?.usage ?? row.conversation.usage ?? void 0
+			});
+			const work = {
+				...assignedWork.has(conversation.conversationId) ? { assignedWork: true } : void 0,
+				...conversationWork.finishedAtById[conversation.conversationId] ? { finishedWorkAt: conversationWork.finishedAtById[conversation.conversationId] } : void 0,
+				...unfinishedWork.has(conversation.conversationId) ? { unfinishedWork: true } : void 0
+			};
+			const annotations = access?.canViewPrivateContent ? annotationsByConversation.get(conversation.conversationId) ?? [] : [];
+			const activityPreview = visibleActivityPreviews.get(conversation.conversationId);
+			const participants = access?.canViewPrivateContent ? participantsByConversation.get(conversation.conversationId) : void 0;
+			return {
+				...summary,
+				...work,
+				...participants && participants.length > 0 ? { participants } : void 0,
+				...activityPreview ? { activityPreview } : void 0,
+				...annotations.length > 0 ? { annotations } : void 0,
+				...sidebarAnnotationsByConversation[conversation.conversationId] ? { sidebarAnnotations: sidebarAnnotationsByConversation[conversation.conversationId] } : void 0,
+				isPriority: isConversationPriority({
+					lastSeenAt: summary.lastSeenAt,
+					lastUserMessageAt: lastUserMessageAtByConversation.get(conversation.conversationId),
+					...work
+				}, nowMs)
+			};
+		}),
+		generatedAt: new Date(nowMs).toISOString(),
+		source: "conversation_index"
 	};
 }
-export { THREAD_OPTOUT_ACK as A, readHealthReport as B, buildSlackInboundMessage as C, normalizeIncomingSlackThreadId as D, stopSlackThread as E, renderSlackObjectCard as F, getAttachmentStorage as I, AGENT_DISPATCH_MAX_AGE_MS as L, parseContent as M, runWithSlackInstallation as N, withNormalizedThreadId as O, verifySlackSignature as P, enqueueAgentDispatch as R, recordSkippedConversationMessage as S, isSlackMessageStopped as T, readViewerAutomationRuns as _, recordWebConversationActivity as a, readViewerAutomations as b, createProductionSlackWebhookServices as c, resolveSlackConversationContextFromThreadId as d, createSlackWebApiStatusSender as f, readViewerAutomationExecutions as g, readConversationSourceTask as h, createConversationId as i, startProcessingReaction as j, stopConversationTurn as k, getProductionSlackAdapter as l, deleteViewerTask as m, conversationTurnIdForMessage as n, webActorFromEmail as o, ViewerTaskNotFoundError as p, createAndEnqueueConversation as r, createProductionConversationWorkOptions as s, appendAndEnqueueWebMessage as t, formatSlackConversationRedactedLabel as u, readViewerAutomationSummary as v, clearSlackPendingReactions as w, resolveViewerTaskCandidate as x, readViewerAutomationVersions as y, GET as z };
+/**
+* Load a bounded feed with an optional viewer-primary linked-user filter.
+*
+* With `viewer` and without `codeRepositoryId`, the feed holds only root
+* Conversations that the viewer started or takes part in, for every `q` and
+* `status`. The `actorEmail` filter and `codeRepositoryId` give no such
+* guarantee, so they are not an authorization boundary.
+*/
+async function readConversationFeed(options = {}) {
+	return conversationFeedSchema.parse(await readConversationFeedFromSql(options));
+}
+export { AGENT_DISPATCH_MAX_AGE_MS as $, assertNoLegacyAllowedDomains as A, normalizeIncomingSlackThreadId as B, readConversationSourceTask as C, readViewerAutomationVersions as D, readViewerAutomationSummary as E, recordSkippedConversationMessage as F, parseContent as G, stopConversationTurn as H, buildSlackInboundMessage as I, canActOnReviewItem as J, ReviewItemActionError as K, clearSlackPendingReactions as L, isAllowedSignInEmail as M, readEnvList as N, readViewerAutomations as O, resolveAllowedDomains as P, getAttachmentStorage as Q, isSlackMessageStopped as R, deleteViewerTask as S, readViewerAutomationRuns as T, THREAD_OPTOUT_ACK as U, withNormalizedThreadId as V, startProcessingReaction as W, readReviewItemForUser as X, isOnlyAssignee as Y, reviewItemChange as Z, createProductionConversationWorkOptions as _, resolveMentions as a, createSlackWebApiStatusSender as b, readConversationAuxiliaryCostsFromSql as c, notCopiedByFork as d, enqueueAgentDispatch as et, childAgentTotalsReport as f, resolveSlackTeamDomains as g, conversationSummaryFromStoredConversation as h, attachConversationMentions as i, isAllowedDomain as j, resolveViewerTaskCandidate as k, ConversationForkError as l, conversationEventHistory as m, readConversationRecordFromSql as n, readHealthReport as nt, readFirstHumanMessageTexts as o, readConversationTreeMetricsFromSql as p, actOnReviewItem as q, readConversationParticipants as r, listConversationSidebarAnnotations as s, readConversationFeed as t, GET as tt, forkConversation as u, createProductionSlackWebhookServices as v, readViewerAutomationExecutions as w, ViewerTaskNotFoundError as x, getProductionSlackAdapter as y, stopSlackThread as z };