@sentry/junior 0.265.0 → 0.267.0

package/dist/{web-input-Y6aXvmfa.js → list-1XQP-o6K.js}

@@ -1,41 +1,43 @@
-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-DGbrur6x.js";
-import { a as completeText, p as escapeXml, r as completeDecision, y as isProviderRetryError } from "./client-DX34VNtH.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-BayQ9hHH.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-D2QBriUo.js";
+import { $n as buildDeterministicTurnId, At as PluginCredentialFailureError, Bt as wasPendingAuthStopped, Ct as isHumanConversationMessage, Dt as turnHasReply, E as sameDefinitionValue, Et as recordDeliveredAssistantMessage, G as commitMessages, Gt as completeTurnRecord, Ht as loadTurnCheckpoint, Jn as trimTrailingAssistantMessages, Jt as listTurnSummaries, Kt as failTurnRecord, Ot as upsertConversationMessage, Pn as persistWithRetry, Pt as AuthorizationFlowDisabledError, Qn as buildDeterministicAssistantMessageId, Rt as clearPendingAuth, S as automationDefinition, St as getConversationMessageSlackTs, Tt as normalizeConversationText, Ut as saveTurnCheckpoint, W as commitAcceptedReply, Wt as abandonTurnRecord, X as loadTurnProjection, Y as loadProjection, Yt as recordTurnSummary, _ as parseEventAutomationRow, bt as createConversationMemoryService, c as withScheduledAutomationLock, cr as isExperimentalFeatureEnabled, dr as configValueSchema, dt as persistConversationMessages, f as deleteEventAutomation, gt as fallbackShortTitle, h as listDeletedEventAutomationsCreatedBy, i as readScheduledAutomation, j as automationEventCatalog, jn as buildTurnErrorResponse, mt as resolveConversationTitle, nr as getSubscribedReplyPreflightDecision, nt as recordAuthorizationCompleted, o as saveScheduledAutomationInLock, ot as recordSubscribedReplyRoute, pr as piMessageFromHistoryItem, pt as persistConversationMessageSummaries, q as loadConversationProjection, qt as getTurnRecord, r as parseScheduledAutomationRow, rr as getThreadStopDecision, tr as decideSubscribedThreadReply, ut as hydrateConversationMessages, vt as appendThreadContextMessages, w as listAutomationVersions, wt as markConversationMessage, xt as estimateConversationContextTokens, yt as buildConversationContext, z as registeredEventTriggerProblems } from "./tasks-0ilmuCux.js";
+import { a as completeText, p as escapeXml, r as completeDecision, y as isProviderRetryError } from "./client-BjgbMawj.js";
+import { c as getSlackClientSecret, i as getChatConfig, l as getSlackSigningSecret, n as botConfig, o as getSlackBotToken, s as getSlackClientId, v as normalizeSlackEmojiName, y as createS3AttachmentStorage } from "./config-CdB6yJj5.js";
+import { B as isRecord, E as withSpan, H as toOptionalString, S as setTags, T as withLogContext, V as toOptionalNumber, b as setSpanAttributes, f as logError, h as logWarn, m as logInfo, n as createChatSdkLogger, o as getActiveTraceContext, p as logException, s as getActiveTraceId, t as buildTurnFailureResponse, y as setSentryUser } from "./logging-DuZ1A4ab.js";
+import { 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-B2wXNspU.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-CAr7xQr2.js";
-import { p as instructionProvenanceFor } from "./history-AY8rs-FR.js";
-import { d as actorLogContext, f as credentialContextForActor } from "./registry-COTeZ2cV.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-C6MwHJEs.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-C6pKlB1p.js";
-import { a as acquireActiveLock, i as MUTATION_LOCK_TTL_MS, r as getStateAdapter, s as withLock } from "./adapter-cUkPH3Om.js";
-import { B as readMessageAttachments, U as isVisionImageMediaType } from "./conversation-B0baEwoA.js";
-import { a as EVENT_SYSTEM_ACTOR, o as isEventConversationMessage } from "./prompt-CvaDdSX3.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-CqRnaZSq.js";
-import { n as getAssistantReplyText } from "./assistant-reply-UPA8vKlC.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-CpCUy1ZJ.js";
-import { a as getVercelConversationWorkQueue, f as getTurnRequestDeadline } from "./job-queue-Cjo6Yg_b.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-DdT74Lvq.js";
-import { l as automationListQuerySchema } from "./automation-2RbKzpMT.js";
+import { a as isUserActor, d as parseSlackTeamId, i as isActorUserId, l as parseSlackChannelId, n as createSlackActor, o as parseActorUserId, p as parseSlackMessageTs, r as createSlackResumeActor, t as createActor } from "./actor-DZSokpwj.js";
+import { T as addAgentTurnUsage, V as requireSlackDestination, _ as loadConversationSlackTenantIds, b as locationFromRow, f as getConversationStore, g as withConversationEventLock, k as hasAgentTurnUsage, m as getSqlExecutor, p as getDb, u as getConversationEventStore, w as parseSessionSource, z as createSlackDestination } from "./viewer-DrN3oC2X.js";
+import { c as juniorIdentities, d as juniorDestinations, l as juniorUsers, o as conversationReadColumns, s as juniorConversations } from "./agent-invocations-CxKldAeB.js";
+import { a as juniorAutomationRuns, f as juniorConversationBriefs, h as juniorConversationEvents, s as juniorAutomations, v as juniorCodeChanges } from "./executor-VYrx_K4w.js";
+import { d as contextProvenance, p as instructionProvenanceFor } from "./history-C84mlAwO.js";
+import { d as actorLogContext, f as credentialContextForActor } from "./registry-FQutO926.js";
+import { B as resolveSlackChannelIdFromThreadId, H as listThreadReplies, J as describeEventAutomationTrigger, L as parseSlackThreadId, R as readSlackRawMessageContext, V as getConversationInfo, Y as effectiveTaskOutcomes, at as conversationSubtreeColumns, b as renderBlockText, ct as buildSteeringPiMessage, i as buildAuthPauseResponse, it as conversationSubtree, lt as withoutSavedSteeringMessages, mt as shouldEmitDevAgentTrace, n as executeAgentRun, p as latestProgressStatus, r as createContextCompactor, t as createAgentRunner, ut as RetryableDeliveryError, w as storeAttachment, y as renderAttachmentText, z as resolveSlackChannelIdFromMessage } from "./agent-runner-DgNATN4D.js";
+import { $ as postSlackMessage, $t as downloadPrivateSlackFile, Bn as conversationNotArchivedForEmail, Fn as conversationArchiveTimes, Ft as cancelSubscriptions, G as normalizeSlackReplyMarkdown, Hn as viewerConversationMembership, In as conversationArchivedForEmail, J as truncateStatusText, K as normalizeSlackStatusText, Kn as buildSentryConversationUrl, Ln as conversationArchivedForUser, Nn as createPluginLogger, Pn as readConversationAccessFromSql, Qt as SlackActionError, Rn as conversationHasParticipantUser, U as escapeSlackMrkdwnText, Vn as conversationNotArchivedForUser, W as formatSlackLink, Xn as recordSlackAttachment, Y as addReactionToMessage, Yn as readAttachmentVisionSummary, Zt as verifyTimerWatchCredentialSubject, an as normalizeSlackConversationId, ar as createPluginCache, dn as JUNIOR_THREAD_STATE_TTL_MS, et as removeReactionFromMessage, fn as getDashboardConversationLink, in as isDmChannel, ir as lookupSlackUser, l as getPluginSlackConversationLink, n as createUserTokenStore, nn as getSlackClient, on as runWithSlackInstallationToken, p as getPlugins, pn as getDashboardObjectIconLink, qn as getSlackFileId, sn as withSlackRetries, tn as getHeaderString, tr as listConversationAnnotationsById, zn as conversationIsMemberRoot } from "./credentialed-CIGwoLU2.js";
+import { a as MUTATION_LOCK_TTL_MS, c as withLock, i as getStateAdapter, o as acquireActiveLock } from "./adapter-BybMEezj.js";
+import { W as readMessageAttachments, g as conversationFeedSchema, q as isVisionImageMediaType } from "./conversation-DSo310Ps.js";
+import { a as EVENT_SYSTEM_ACTOR, o as isEventConversationMessage } from "./prompt-BW9jFsqZ.js";
+import { B as ConversationTurnBoundaryError, G as isCooperativeTurnYieldError, H as TurnInputCommitLostError, J as markTurnClosed, K as isTurnInputCommitLostError, U as TurnInputDeferredError, V as CooperativeTurnYieldError, W as getConversationTurnBoundaryError, X as markTurnFailed, Y as markTurnCompleted, Z as startActiveTurn, q as isTurnInputDeferredError } from "./store-6EetVP-m.js";
+import { n as getAssistantReplyText } from "./assistant-reply-CT7VcXQe.js";
+import { C as maybePostAutomatedTurnLimitNotice, M as runDispatchOutcome, O as deliversFinalText, c as isEventMailboxMetadata, d as getEventCatalog, i as skipInputBeforeConversationStop, k as finishedRunReply, l as renderEventBatchText, s as eventBatchMessageEvents, u as timerWatchCredentialSubject, w as recordFinishedTurnForAutomatedLimit, x as joinMailboxText } from "./session-stop-DkOjt46_.js";
+import { a as getVercelConversationWorkQueue, f as getTurnRequestDeadline } from "./job-queue-C0BZSa7r.js";
+import { D as stopConversationWork, g as getConversationWorkState, h as getConversation, m as ensureConversationWake, n as appendAndEnqueueExclusiveInboundMessage, r as appendAndEnqueueInboundMessage, w as requestConversationWork } from "./store-DvNZIsCr.js";
+import { j as eventAutomationTriggerSchema, l as automationListQuerySchema } from "./automation-CmeFBSEh.js";
 import { c as sumUtcHoursIntoSixHours, m as healthReportSchema, t as webMessageId } from "./web-message-id-CJSUiksE.js";
-import { A as readAutomationExecutions, D as readAutomationExecutionStatusDays, E as readAutomationExecutionHours, 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-6mLmG6g_.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-COnC42GR.js";
-import { n as getTurnLifecycle, t as ConversationTurnLifecycleService } from "./turn-lifecycle-C35IyRGp.js";
-import { i as resolveAgentInvocationId, o as AgentRunError, s as executeTurn, t as createAgentInvocationWorker } from "./work-DMbqK0kT.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-D45lz-oC.js";
-import { c as deleteWebAuthorization, d as createPausedTurns, f as getPausedTurnRequest, h as getTurnAuthorization, m as wakePausedTurn, s as createWebAuthorization } from "./connections-mpN5Lsnj.js";
-import { n as resolveTurnSessionRouting } from "./turn-session-routing-BKx6rfVd.js";
-import { t as bindMessageAgent } from "./message-C9ymnpBS.js";
-import { t as bindSpawnAgent } from "./spawn-mbTcrLb3.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-CaEPLSBn.js";
-import { r as storeInputImages } from "./images-B2yA3HWE.js";
+import { A as readAutomationExecutions, D as readAutomationExecutionStatusDays, E as readAutomationExecutionHours, M as readAutomationTitlesByConversationId, O as readAutomationExecutionStatusHours, S as emptyAutomationRunWindows, T as readAutomationExecutionDays, _ as markDispatchBlocked, a as claimDispatchMailboxAppend, b as markDispatchRunning, c as getDispatchConversationId, d as getDispatchRecord, f as getDispatchTurnId, g as markDispatchAwaitingResume, j as readAutomationRuns, k as readAutomationExecutionSummaries, l as getDispatchIdForConversation, m as isTerminalDispatchStatus, n as scheduleSessionCompletedPluginTasks, o as confirmDispatchMailboxAppend, t as processPluginTask, u as getDispatchInputMessageId, v as markDispatchCompleted, w as readAutomationExecutionByConversationId, y as markDispatchFailed } from "./task-runner-B-PD_JOj.js";
+import { a as withAgentInvocationResultActors, c as resolveMailboxTurnWork, d as legacyWebMailboxMetadataSchema, i as startAgentInvocationsForChildInput, l as sourceFromTurnInput, o as getAuthPausedConversationTurnId, s as getEventBatchDelayMs, t as enqueueAgentInvocationResult, u as turnInputFactsFromConversationMessage } from "./result-B9e9ATOU.js";
+import { n as getTurnLifecycle, t as ConversationTurnLifecycleService } from "./turn-lifecycle-OzLIwvi1.js";
+import { i as resolveAgentInvocationId, o as AgentRunError, s as executeTurn, t as createAgentInvocationWorker } from "./work-DUQoNcqP.js";
+import { a as persistThreadState, i as persistThreadRuntimeState, n as getPersistedSandboxState, o as persistThreadStateById, r as getPersistedThreadState, s as coerceThreadConversationState, t as getLocationConfigurationService } from "./thread-state-DRmdJ2QN.js";
+import { c as deleteWebAuthorization, d as createPausedTurns, f as getPausedTurnRequest, h as getTurnAuthorization, m as wakePausedTurn, s as createWebAuthorization } from "./connections-RE_65jzK.js";
+import { n as resolveTurnSessionRouting } from "./turn-session-routing-Dyut9l7Y.js";
+import { t as bindMessageAgent } from "./message-NKSbbnA6.js";
+import { t as bindSpawnAgent } from "./spawn-BHuqN14f.js";
+import { a as persistAuthPauseTurnState, c as getTurnUserSlackMessageTs, d as loadPendingMessageCards, i as completeAuthPauseTurn, l as buildDeliveredTurnStatePatch, n as getAgentTurnDiagnosticsAttributes, o as getTurnUserMessage, r as requireTurnFailureEventId, s as getTurnUserReplyAttachmentContext, t as finalizeFailedTurnReplyWithEvent, u as getInterruptionMarker } from "./turn-failure-response-G11cs2gE.js";
+import { r as storeInputImages } from "./images-CecjXAAz.js";
 import { 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, createWebSource, localDestinationSchema, objectFactFields, objectPresentation, 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 +109,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 +214,6 @@ async function persistBlockedDispatchTurn(dispatch, error) {
 		actor: dispatch.actor,
 		conversationId,
 		destination: dispatch.destination,
-		destinationVisibility: dispatch.destinationVisibility,
 		dispatchId: dispatch.id,
 		dispatchOutcome: "blocked",
 		turnId: sessionId,
@@ -850,6 +850,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.
 *
@@ -1233,7 +1263,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, {
@@ -1375,7 +1405,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);
@@ -2166,7 +2196,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 +2244,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 +2294,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 +2327,8 @@ function buildSlackInboundMessage(args) {
 				thread: serializedThreadSchema.parse(args.thread.toJSON()),
 				message: args.message.toJSON()
 			}
-		}
+		},
+		traceContext: getActiveTraceContext()
 	};
 }
 // src/chat/slack/message/identity.ts
@@ -2784,6 +2816,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 +2882,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 +2892,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 +2904,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 +3055,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 +3109,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),
@@ -4327,10 +4417,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 +4427,10 @@ function createSlackTurn(deps) {
 			messageTs,
 			teamId,
 			threadTs,
-			visibility: destinationVisibility ?? "private"
+			visibility: await resolveDestinationVisibility({
+				destination,
+				visibility: destinationVisibility
+			}) ?? "private"
 		});
 		const slackActionToken = readSlackActionToken(message);
 		const runId = options.execution?.dispatch?.id ?? getRunId(thread, message);
@@ -5448,7 +5538,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,
@@ -5767,7 +5856,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({
@@ -5813,7 +5902,6 @@ async function resumeSlackTurnInContext(args) {
 		if (runArgs.initialText) await postSlackMessageBestEffort(runArgs.channelId, runArgs.threadTs, 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 +5996,6 @@ async function resumeSlackTurnInContext(args) {
 				await persistWithRetry(() => recordTurnSummary({
 					conversationId: runArgs.conversationId,
 					destination: savedRun.destination,
-					destinationVisibility: visibility,
 					dispatchId,
 					resultMessageId: messageTs,
 					turnId: runArgs.turnId,
@@ -5954,7 +6041,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 +6053,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,
@@ -6269,6 +6354,7 @@ async function runPausedTurnInContext(payload, options, runOptions) {
 		messageText: "",
 		conversationId: payload.conversationId,
 		turnId: payload.turnId,
+		traceContext: payload.traceContext,
 		channelId: thread?.channelId ?? destination.channelId,
 		...thread?.threadTs ? { threadTs: thread.threadTs } : void 0,
 		executeTurn: async (run, saveResult) => await executeTurn(options.agentRunner, run, saveResult),
@@ -6653,6 +6739,64 @@ async function commitAssistantMessage(args) {
 		logException(error, "conversation.assistant.message_persist.failed");
 	}
 }
+// 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
+	};
+}
+/**
+* Drain steered web messages into the active web Turn.
+*
+* 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 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/conversations/destination.ts
 function requireLocalDestination(conversationId) {
 	const parsed = localDestinationSchema.safeParse({
@@ -6982,6 +7126,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) => {
@@ -7481,4 +7632,1156 @@ async function appendAndEnqueueWebMessage(input, options) {
 		status
 	};
 }
-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 };
+// 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;
+}
+/** 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 direct Slack archive URL for a thread when the workspace domain is
+* known. Omits a link rather than falling back to `app_redirect`.
+*/
+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;
+	}
+}
+/** 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
+	});
+}
+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"
+	};
+}
+/** 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 {
+		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
+	};
+}
+// 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 {
+		...auxiliaryCosts?.childAgentCostUsd === void 0 ? void 0 : { auxiliaryCostUsd: auxiliaryCosts.childAgentCostUsd },
+		count: childAgents.count,
+		cumulativeDurationMs: childAgents.durationMs,
+		...childAgents.usage ? { cumulativeUsage: childAgents.usage } : void 0
+	};
+}
+// 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}
+  )`;
+}
+/**
+* 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.actorEmail,
+		idempotencyKey: JSON.stringify([
+			"fork",
+			input.sourceConversationId,
+			input.idempotencyKey
+		])
+	});
+	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 };
+	}));
+}
+/**
+* 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 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] : [];
+		});
+	});
+}
+/**
+* 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 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 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 {
+		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"
+	};
+}
+/**
+* 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 { renderSlackObjectCard as $, readViewerAutomationRuns as A, recordSkippedConversationMessage as B, createProductionSlackWebhookServices as C, deleteViewerTask as D, ViewerTaskNotFoundError as E, assertNoLegacyAllowedDomains as F, normalizeIncomingSlackThreadId as G, clearSlackPendingReactions as H, isAllowedDomain as I, THREAD_OPTOUT_ACK as J, withNormalizedThreadId as K, isAllowedSignInEmail as L, readViewerAutomationVersions as M, readViewerAutomations as N, readConversationSourceTask as O, resolveViewerTaskCandidate as P, verifySlackSignature as Q, readEnvList as R, createProductionConversationWorkOptions as S, createSlackWebApiStatusSender as T, isSlackMessageStopped as U, buildSlackInboundMessage as V, stopSlackThread as W, parseContent as X, startProcessingReaction as Y, runWithSlackInstallation as Z, appendAndEnqueueWebMessage as _, resolveMentions as a, recordWebConversationActivity as b, readConversationAuxiliaryCostsFromSql as c, notCopiedByFork as d, getAttachmentStorage as et, childAgentTotalsReport as f, resolveSlackTeamDomains as g, conversationSummaryFromStoredConversation as h, attachConversationMentions as i, readHealthReport as it, readViewerAutomationSummary as j, readViewerAutomationExecutions as k, ConversationForkError as l, conversationEventHistory as m, readConversationRecordFromSql as n, enqueueAgentDispatch as nt, readFirstHumanMessageTexts as o, readConversationTreeMetricsFromSql as p, stopConversationTurn as q, readConversationParticipants as r, GET as rt, listConversationSidebarAnnotations as s, readConversationFeed as t, AGENT_DISPATCH_MAX_AGE_MS as tt, forkConversation as u, conversationTurnIdForMessage as v, getProductionSlackAdapter as w, webActorFromEmail as x, createAndEnqueueConversation as y, resolveAllowedDomains as z };