@sentry/junior 0.272.0 → 0.273.0

package/dist/{list-JZUP1yog.js → stop-dKUc-x2K.js}

@@ -1,45 +1,46 @@
-import { $t as appendThreadContextMessages, An as recordTurnSummary, Ar as trimTrailingAssistantMessages, At as loadProjection, Cn as loadTurnCheckpoint, Dn as failTurnRecord, En as completeTurnRecord, Et as commitMessages, Fr as buildDeterministicTurnId, Gt as hydrateConversationMessages, Jt as persistConversationMessageSummaries, Kt as persistConversationMessages, Lr as decideSubscribedThreadReply, Lt as recordAuthorizationCompleted, On as getTurnRecord, Ot as loadConversationProjection, Pr as buildDeterministicAssistantMessageId, Rr as getSubscribedReplyPreflightDecision, Tn as abandonTurnRecord, Tt as commitAcceptedReply, Vt as recordSubscribedReplyRoute, Wr as isExperimentalFeatureEnabled, Yr as piMessageFromHistoryItem, Yt as resolveConversationTitle, Zt as fallbackShortTitle, _ as markDispatchCompleted, a as confirmDispatchMailboxAppend, an as markConversationMessage, cn as turnHasReply, d as getDispatchTurnId, dn as PluginCredentialFailureError, en as buildConversationContext, fr as buildTurnErrorResponse, g as markDispatchBlocked, gr as persistWithRetry, h as markDispatchAwaitingResume, hn as AuthorizationFlowDisabledError, i as claimDispatchMailboxAppend, in as isHumanConversationMessage, j as readAutomationTitlesByConversationId, jt as loadTurnProjection, kn as listTurnSummaries, l as getDispatchInputMessageId, ln as upsertConversationMessage, n as resolveTurnSessionRouting, nn as estimateConversationContextTokens, on as normalizeConversationText, p as isTerminalDispatchStatus, qr as configValueSchema, rn as getConversationMessageSlackTs, s as getDispatchConversationId, sn as recordDeliveredAssistantMessage, t as resolveConversationRouting, tn as createConversationMemoryService, u as getDispatchRecord, v as markDispatchFailed, wn as saveTurnCheckpoint, xn as wasPendingAuthStopped, y as markDispatchRunning, yn as clearPendingAuth, zr as getThreadStopDecision } from "./turn-session-routing-BV_gX7n3.js";
-import { a as completeText, p as escapeXml, r as completeDecision, y as isProviderRetryError } from "./client-FRphcDWW.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-BUP9wjiR.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-CjkDr-jP.js";
+import { $ as loadTurnCheckpoint, $a as configValueSchema, A as buildConversationContext, Aa as conversationNotArchivedForEmail, Bi as verifyTimerWatchCredentialSubject, Bn as closeReviewItem, Br as addReactionToMessage, Ca as createPluginLogger, D as fallbackShortTitle, Da as conversationArchivedForUser, Ea as conversationArchivedForEmail, F as markConversationMessage, Fa as readConversationEventPage, G as AuthorizationFlowDisabledError, Gi as getSlackClient, Ha as recordSlackAttachment, Hi as downloadPrivateSlackFile, Ht as buildTurnErrorResponse, I as normalizeConversationText, Ia as buildSentryConversationUrl, Ji as normalizeSlackConversationId, Ka as listConversationAnnotations, Kn as listReplyActionItems, Kt as persistWithRetry, L as recordDeliveredAssistantMessage, Lr as normalizeSlackStatusText, M as estimateConversationContextTokens, Ma as viewerConversationMembership, N as getConversationMessageSlackTs, Nn as getPlugins, Oa as conversationHasParticipantUser, P as isHumanConversationMessage, Pa as readLatestConversationBrief, Qn as canActOnReviewItem, R as turnHasReply, Ra as notInheritedByForkChild, S as persistConversationMessages, Sn as createUserTokenStore, T as resolveConversationTitle, Ta as conversationArchiveTimes, V as PluginCredentialFailureError, Va as readAttachmentVisionSummary, Vi as SlackActionError, Wi as getHeaderString, Wn as getReviewItem, Xa as lookupSlackUser, Xi as withSlackRetries, Y as clearPendingAuth, Yn as takeReviewItem, Z as wasPendingAuthStopped, Za as createPluginCache, _ as recordSubscribedReplyRoute, ar as reviewItemReaderForUser, at as listTurnSummaries, bn as isExperimentalFeatureEnabled, dn as buildDeterministicTurnId, ea as JUNIOR_THREAD_STATE_TTL_MS, er as canReadReviewItem, et as saveTurnCheckpoint, hn as getThreadStopDecision, i as loadConversationProjection, it as getTurnRecord, j as createConversationMemoryService, ja as conversationNotArchivedForUser, k as appendThreadContextMessages, ka as conversationIsMemberRoot, mn as getSubscribedReplyPreflightDecision, n as commitMessages, nt as completeTurnRecord, o as loadProjection, on as trimTrailingAssistantMessages, ot as recordTurnSummary, p as recordAuthorizationCompleted, pn as decideSubscribedThreadReply, qa as listConversationAnnotationsById, qi as isDmChannel, qr as removeReactionFromMessage, rt as failTurnRecord, s as loadTurnProjection, t as commitAcceptedReply, to as piMessageFromHistoryItem, tr as isOnlyAssignee, tt as abandonTurnRecord, un as buildDeterministicAssistantMessageId, w as persistConversationMessageSummaries, wa as readConversationAccessFromSql, wi as cancelSubscriptions, x as hydrateConversationMessages, z as upsertConversationMessage, za as getSlackFileId, zr as truncateStatusText } from "./projection-BOpi891B.js";
+import { a as completeText, b as isProviderRetryError, m as escapeXml, r as completeDecision } from "./client-DhqbV0Fe.js";
+import { _ as normalizeSlackEmojiName, c as getSlackClientSecret, i as getChatConfig, l as getSlackSigningSecret, n as botConfig, o as getSlackBotToken, s as getSlackClientId, v as createS3AttachmentStorage } from "./config-C6FTd7PX.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-CNs1e04n.js";
 import { i as getActiveSpan, r as continueTrace } from "./sentry-MDkYAVPV.js";
 import { i as defaultModelId, r as boundProfile, s as modelIdForProfile } from "./model-profile-B998sjVd.js";
 import { f as parseSlackTeamId, h as parseSlackMessageTs, i as isActorUserId, n as createSlackActor, o as isUserActor, r as createSlackResumeActor, s as parseActorUserId, t as createActor, u as parseSlackChannelId } from "./actor-B4DYygOB.js";
-import { C as getSqlExecutor, E as loadConversationSlackTenantIds, H as parseSessionSource, M as resolveActorIdentityId, N as saveActorAvatar, S as getDb, T as withConversationEventLock, U as addAgentTurnUsage, Y as createSlackDestination, Z as requireSlackDestination, f as identityAvatarUrl, h as readUserAvatarUrls, k as locationFromRow, q as hasAgentTurnUsage, x as getConversationStore, y as getConversationEventStore } from "./viewer-BCRuO8Wg.js";
+import { A as locationFromRow, C as getSqlExecutor, D as loadConversationSlackTenantIds, E as withConversationEventLock, J as hasAgentTurnUsage, N as resolveActorIdentityId, P as saveActorAvatar, Q as requireSlackDestination, S as getDb, U as parseSessionSource, W as addAgentTurnUsage, X as createSlackDestination, Y as resolveRootConversationId, f as identityAvatarUrl, h as readUserAvatarUrls, q as agentTurnUsageSchema, x as getConversationStore, y as getConversationEventStore } from "./viewer-C6Y1aXjZ.js";
 import { c as juniorIdentities, d as juniorDestinations, l as juniorUsers, o as conversationReadColumns, s as juniorConversations } from "./agent-invocations-C1RNOCs8.js";
-import { C as juniorCodeChanges, _ as juniorConversationBriefs, b as juniorConversationEvents, h as juniorConversationParticipants } from "./executor-DGDpyegI.js";
+import { C as juniorCodeChanges, _ as juniorConversationBriefs, b as juniorConversationEvents, h as juniorConversationParticipants, m as juniorConversationReadPositions } from "./executor-BafgvQcc.js";
 import { g as instructionProvenanceFor, m as contextProvenance, r as isVisionImageMediaType } from "./media-U6Tuz6Mi.js";
-import { d as actorLogContext, f as credentialContextForActor } from "./registry-7XgwNgQe.js";
-import { Ct as conversationSubtree, Dt as buildSteeringPiMessage, F as getConversationInfo, Ft as shouldEmitDevAgentTrace, L as listThreadReplies, M as readSlackRawMessageContext, N as resolveSlackChannelIdFromMessage, Ot as withoutSavedSteeringMessages, P as resolveSlackChannelIdFromThreadId, R as resolveDestinationVisibility, b as renderBlockText, ct as createConversationId, dt as resolveConversationDestination, gt as storeAttachment, i as buildAuthPauseResponse, j as parseSlackThreadId, jt as RetryableDeliveryError, k as runWithSlackInstallation, lt as recordWebConversationActivity, n as executeAgentRun, nt as deliverReviewItemChange, p as latestProgressStatus, r as createContextCompactor, t as createAgentRunner, ut as webActorFromEmail, wt as conversationSubtreeColumns, y as renderAttachmentText } from "./agent-runner-Cl6Usx2Y.js";
-import { An as normalizeSlackConversationId, Ar as lookupSlackUser, Cn as SlackActionError, Dn as getSlackClient, Dr as listConversationAnnotationsById, Dt as removeReactionFromMessage, E as listReplyActionItems, En as getHeaderString, F as isOnlyAssignee, In as JUNIOR_THREAD_STATE_TTL_MS, M as canActOnReviewItem, Mn as withSlackRetries, P as canReadReviewItem, Sn as verifyTimerWatchCredentialSubject, Sr as recordSlackAttachment, _t as normalizeSlackStatusText, ar as createPluginLogger, b as closeReviewItem, bt as addReactionToMessage, cr as conversationArchivedForEmail, dr as conversationIsMemberRoot, fr as conversationNotArchivedForEmail, jr as createPluginCache, k as takeReviewItem, kn as isDmChannel, lr as conversationArchivedForUser, mr as viewerConversationMembership, n as createUserTokenStore, on as cancelSubscriptions, or as readConversationAccessFromSql, p as getPlugins, pr as conversationNotArchivedForUser, sr as conversationArchiveTimes, ur as conversationHasParticipantUser, w as getReviewItem, wn as downloadPrivateSlackFile, xr as readAttachmentVisionSummary, yr as getSlackFileId, yt as truncateStatusText, z as reviewItemReaderForUser } from "./credentialed-CgTulRDH.js";
+import { d as actorLogContext, f as credentialContextForActor } from "./registry-B-yUrv3h.js";
+import { Ct as conversationSubtree, Dt as buildSteeringPiMessage, F as getConversationInfo, Ft as shouldEmitDevAgentTrace, L as listThreadReplies, M as readSlackRawMessageContext, N as resolveSlackChannelIdFromMessage, Ot as withoutSavedSteeringMessages, P as resolveSlackChannelIdFromThreadId, R as resolveDestinationVisibility, b as renderBlockText, ct as createConversationId, dt as resolveConversationDestination, gt as storeAttachment, i as buildAuthPauseResponse, j as parseSlackThreadId, jt as RetryableDeliveryError, k as runWithSlackInstallation, lt as recordWebConversationActivity, n as executeAgentRun, nt as deliverReviewItemChange, p as latestProgressStatus, q as readConversationSourceTask, r as createContextCompactor, t as createAgentRunner, ut as webActorFromEmail, wt as conversationSubtreeColumns, y as renderAttachmentText } from "./agent-runner-D7Qz-lGO.js";
 import { a as withLock, n as MUTATION_LOCK_TTL_MS, r as acquireActiveLock } from "./locks-D-0h111u.js";
-import { r as getStateAdapter } from "./adapter-BDYDi1F9.js";
-import { G as readMessageAttachments, g as conversationFeedSchema } from "./conversation-BtQzLoK8.js";
-import { a as EVENT_SYSTEM_ACTOR, o as isEventConversationMessage } from "./prompt-vfceH0c-.js";
-import { $ as startActiveTurn, G as TurnInputDeferredError, H as ConversationTurnBoundaryError, J as isTurnInputCommitLostError, K as getConversationTurnBoundaryError, Q as markTurnFailed, U as CooperativeTurnYieldError, W as TurnInputCommitLostError, X as markTurnClosed, Y as isTurnInputDeferredError, Z as markTurnCompleted, q as isCooperativeTurnYieldError } from "./store-DyVKH0QB.js";
-import { n as getAssistantReplyText } from "./assistant-reply-DN2w6JL_.js";
-import { A as recordFinishedTurnForAutomatedLimit, D as sendSlackReply, E as resolveSlackReplyTarget, F as finishedRunReply, I as postsRunNotices, P as deliversFinalText, S as joinMailboxText, c as isEventMailboxMetadata, i as skipInputBeforeConversationStop, l as renderEventBatchText, s as eventBatchMessageEvents, u as timerWatchCredentialSubject, w as maybePostAutomatedTurnLimitNotice, z as runDispatchOutcome } from "./session-stop-HKl0ECX0.js";
+import { r as getStateAdapter } from "./adapter-umap1cth.js";
+import { G as readMessageAttachments, d as conversationDetailReportSchema, g as conversationFeedSchema } from "./conversation-T4oabbBi.js";
+import { a as EVENT_SYSTEM_ACTOR, o as isEventConversationMessage } from "./prompt-B1ySjUyf.js";
+import { $ as startActiveTurn, G as TurnInputDeferredError, H as ConversationTurnBoundaryError, J as isTurnInputCommitLostError, K as getConversationTurnBoundaryError, Q as markTurnFailed, U as CooperativeTurnYieldError, W as TurnInputCommitLostError, X as markTurnClosed, Y as isTurnInputDeferredError, Z as markTurnCompleted, m as getChildAgentLabel, q as isCooperativeTurnYieldError } from "./store-C1xuZcLd.js";
+import { n as getAssistantReplyText } from "./assistant-reply-wZ7i4OFa.js";
+import { A as recordFinishedTurnForAutomatedLimit, D as sendSlackReply, E as resolveSlackReplyTarget, F as finishedRunReply, I as postsRunNotices, P as deliversFinalText, S as joinMailboxText, c as isEventMailboxMetadata, i as skipInputBeforeConversationStop, l as renderEventBatchText, s as eventBatchMessageEvents, u as timerWatchCredentialSubject, w as maybePostAutomatedTurnLimitNotice, z as runDispatchOutcome } from "./session-stop-DaT_7tYa.js";
 import { _ as isEmptyUserInputAnswer, v as normalizeUserInputAnswer } from "./reporting-window-DgHgwQB3.js";
-import { a as getVercelConversationWorkQueue, f as getTurnRequestDeadline } from "./job-queue-CjB97sii.js";
-import { D as stopConversationWork, g as getConversationWorkState, h as getConversation, m as ensureConversationWake, r as appendAndEnqueueInboundMessage, w as requestConversationWork } from "./store-CPF2kzbu.js";
-import { t as healthReportSchema } from "./reporting-schema-CZREhYc-.js";
-import { a as withAgentInvocationResultActors, c as listActiveMailboxTurns, d as turnInputFactsFromConversationMessage, f as legacyWebMailboxMetadataSchema, l as resolveMailboxTurnWork, n as enqueueAgentInvocationResult, o as getAuthPausedConversationTurnId, s as getEventBatchDelayMs, t as createChildConversationWorker, u as sourceFromTurnInput } from "./result-BRhb6iN1.js";
-import { n as getTurnLifecycle, t as ConversationTurnLifecycleService } from "./turn-lifecycle-DM_77q33.js";
-import { a as AgentRunError, o as executeTurn } from "./work-zxkmbJAp.js";
-import { a as persistThreadStateById, i as persistThreadRuntimeState, n as getPersistedSandboxState, o as coerceThreadConversationState, r as getPersistedThreadState, t as getLocationConfigurationService } from "./thread-state-Ds8JTsX6.js";
-import { c as deleteWebAuthorization, d as createPausedTurns, f as getPausedTurnRequest, h as getTurnAuthorization, m as wakePausedTurn, s as createWebAuthorization } from "./connections-CesHau9u.js";
-import { t as bindMessageAgent } from "./message-D9y8PKA1.js";
-import { t as bindSpawnAgent } from "./spawn-DqjBxqWh.js";
-import { n as scheduleSessionCompletedPluginTasks, t as processPluginTask } from "./task-runner-ChzW5E7R.js";
-import { a as persistAuthPauseTurnState, c as getTurnUserSlackMessageTs, i as completeAuthPauseTurn, l as buildDeliveredTurnStatePatch, n as getAgentTurnDiagnosticsAttributes, o as getTurnUserMessage, r as requireTurnFailureEventId, s as getTurnUserReplyAttachmentContext, t as finalizeFailedTurnReplyWithEvent, u as loadPendingMessageCards } from "./turn-failure-response-DCMvjsA0.js";
+import { a as getVercelConversationWorkQueue, f as getTurnRequestDeadline } from "./job-queue-C4lphW9Y.js";
+import { D as stopConversationWork, g as getConversationWorkState, h as getConversation, m as ensureConversationWake, r as appendAndEnqueueInboundMessage, w as requestConversationWork } from "./store-DaxUuOmD.js";
+import { _ as markDispatchCompleted, a as confirmDispatchMailboxAppend, d as getDispatchTurnId, g as markDispatchBlocked, h as markDispatchAwaitingResume, i as claimDispatchMailboxAppend, j as readAutomationTitlesByConversationId, l as getDispatchInputMessageId, n as resolveTurnSessionRouting, p as isTerminalDispatchStatus, s as getDispatchConversationId, t as resolveConversationRouting, u as getDispatchRecord, v as markDispatchFailed, y as markDispatchRunning } from "./turn-session-routing-BdCTDq9m.js";
+import { n as healthReportSchema, t as apiErrorSchema } from "./common-Eu6sx09c.js";
+import { a as withAgentInvocationResultActors, c as listActiveMailboxTurns, d as turnInputFactsFromConversationMessage, f as legacyWebMailboxMetadataSchema, l as resolveMailboxTurnWork, n as enqueueAgentInvocationResult, o as getAuthPausedConversationTurnId, s as getEventBatchDelayMs, t as createChildConversationWorker, u as sourceFromTurnInput } from "./result-DQwTiLTw.js";
+import { n as getTurnLifecycle, t as ConversationTurnLifecycleService } from "./turn-lifecycle-BdPKdPS8.js";
+import { a as AgentRunError, o as executeTurn } from "./work-ChPh_YEh.js";
+import { a as persistThreadStateById, i as persistThreadRuntimeState, n as getPersistedSandboxState, o as coerceThreadConversationState, r as getPersistedThreadState, t as getLocationConfigurationService } from "./thread-state-BkUpE9Ae.js";
+import { c as deleteWebAuthorization, d as createPausedTurns, f as getPausedTurnRequest, h as getTurnAuthorization, m as wakePausedTurn, s as createWebAuthorization } from "./connections-Dq72KajR.js";
+import { t as bindMessageAgent } from "./message-CETC5lsl.js";
+import { t as bindSpawnAgent } from "./spawn-Ceikdjkp.js";
+import { n as scheduleSessionCompletedPluginTasks, t as processPluginTask } from "./task-runner-vlH6pEm3.js";
+import { a as persistAuthPauseTurnState, c as getTurnUserSlackMessageTs, i as completeAuthPauseTurn, l as buildDeliveredTurnStatePatch, n as getAgentTurnDiagnosticsAttributes, o as getTurnUserMessage, r as requireTurnFailureEventId, s as getTurnUserReplyAttachmentContext, t as finalizeFailedTurnReplyWithEvent, u as loadPendingMessageCards } from "./turn-failure-response-DIsD7ip_.js";
+import { createHash, createHmac, timingSafeEqual } from "node:crypto";
 import { z } from "zod";
-import { createHash } from "node:crypto";
-import { and, asc, desc, eq, inArray, isNotNull, isNull, or, sql } from "drizzle-orm";
+import { and, asc, desc, eq, inArray, isNotNull, isNull, max, or, sql } from "drizzle-orm";
 import { conversationSidebarAnnotationSchema, createSlackSource, objectTypeSchema } from "@sentry/junior-plugin-api";
 import { alias } from "drizzle-orm/pg-core";
 import { del, get, put } from "@vercel/blob";
 import { Message, ThreadImpl, stringifyMarkdown } from "chat";
 import { SlackFormatConverter, createSlackAdapter } from "@chat-adapter/slack";
+import { HTTPException } from "hono/http-exception";
 // src/handlers/health.ts
 /** Build Junior's process health value for HTTP and reporting consumers. */
 function readHealthReport() {
@@ -2265,7 +2266,6 @@ function getPendingRecords(work) {
 }
 /** Build the worker run function for queued Slack conversation work. */
 function createSlackConversationWorker(options) {
-	const crossActorMidRunMode = options.crossActorMidRunMode ?? botConfig.crossActorMidRunMode;
 	return async (context) => {
 		const adapter = options.getSlackAdapter();
 		const actorLookup = options.lookupSlackUser ?? lookupSlackUser;
@@ -2352,7 +2352,7 @@ function createSlackConversationWorker(options) {
 								adapter,
 								record
 							})
-						})).filter((candidate) => crossActorMidRunMode === "steer" || requireSlackAuthorId(candidate.message) === activeAuthorId || hasSteeringOverride(candidate.message.text));
+						})).filter((candidate) => requireSlackAuthorId(candidate.message) === activeAuthorId);
 						return candidates.length > 0 ? await accept(candidates) : [];
 					});
 				};
@@ -6772,6 +6772,139 @@ function createProductionConversationWorkOptions(options) {
 		waitUntil: options.waitUntil
 	});
 }
+// src/api/http.ts
+const NO_STORE_HEADERS = { "cache-control": "no-store" };
+/** Build response init that keeps personalized API payloads out of shared caches. */
+function noStoreInit(init) {
+	if (!init) return { headers: NO_STORE_HEADERS };
+	const headers = new Headers(init.headers);
+	if (!headers.has("cache-control")) headers.set("cache-control", "no-store");
+	return {
+		...init,
+		headers
+	};
+}
+/** Serialize a REST response only after it satisfies its declared schema. */
+function jsonResponse(schema, value, init) {
+	return Response.json(schema.parse(value), noStoreInit(init));
+}
+/** Return an empty personalized API response with no-store caching. */
+function emptyResponse(status = 204) {
+	return new Response(null, noStoreInit({ status }));
+}
+/** Stop a request with Junior's stable JSON error contract. */
+function throwApiError(status, message, cause) {
+	throw new HTTPException(status, {
+		...cause === void 0 ? void 0 : { cause },
+		message,
+		res: jsonResponse(apiErrorSchema, { error: message }, { status })
+	});
+}
+// src/api/conversations/archive.ts
+async function setViewerArchive(args) {
+	const executor = getSqlExecutor();
+	return await executor.transaction(async () => {
+		const db = executor.db();
+		const [root] = await db.select({ lastActivityAt: juniorConversations.lastActivityAt }).from(juniorConversations).where(eq(juniorConversations.conversationId, args.rootConversationId)).limit(1).for("update");
+		if (!root) return { status: "missing" };
+		if (args.archived) {
+			if (root.lastActivityAt.getTime() !== Date.parse(args.lastSeenAt)) return { status: "conflict" };
+			const archivedAt = /* @__PURE__ */ new Date();
+			const lastMessageAt = new Date(args.lastSeenAt);
+			await db.insert(juniorConversationParticipants).values({
+				archivedAt,
+				lastMessageAt,
+				rootConversationId: args.rootConversationId,
+				userId: args.userId
+			}).onConflictDoUpdate({
+				target: [juniorConversationParticipants.userId, juniorConversationParticipants.rootConversationId],
+				set: {
+					archivedAt,
+					lastMessageAt: sql`greatest(${juniorConversationParticipants.lastMessageAt}, excluded.last_message_at)`
+				}
+			});
+			return {
+				archivedAt: archivedAt.toISOString(),
+				status: "updated"
+			};
+		}
+		await db.update(juniorConversationParticipants).set({ archivedAt: null }).where(and(eq(juniorConversationParticipants.userId, args.userId), eq(juniorConversationParticipants.rootConversationId, args.rootConversationId), isNotNull(juniorConversationParticipants.archivedAt)));
+		return {
+			archivedAt: null,
+			status: "updated"
+		};
+	});
+}
+/** Read one viewer's archive timestamp for a conversation root. */
+async function readConversationArchivedAt(viewer, conversationId) {
+	const rootConversationId = await resolveRootConversationId(getSqlExecutor(), conversationId);
+	const [row] = await getDb().select({ archivedAt: juniorConversationParticipants.archivedAt }).from(juniorConversationParticipants).where(and(eq(juniorConversationParticipants.userId, viewer.id), eq(juniorConversationParticipants.rootConversationId, rootConversationId))).limit(1);
+	return row?.archivedAt?.getTime();
+}
+/** Archive or restore one conversation for the signed-in viewer. */
+async function archiveConversation(viewer, conversationId, body) {
+	if (!(await readConversationAccessFromSql(getDb(), [conversationId], viewer)).get(conversationId)?.isParticipant) throwApiError(404, "Conversation not found.");
+	const rootConversationId = await resolveRootConversationId(getSqlExecutor(), conversationId);
+	const result = await setViewerArchive({
+		archived: body.archived,
+		lastSeenAt: body.lastSeenAt,
+		rootConversationId,
+		userId: viewer.id
+	});
+	if (result.status === "updated") return { archivedAt: result.archivedAt };
+	if (result.status === "missing") throwApiError(404, "Conversation not found.");
+	throwApiError(409, "Conversation received new activity.");
+}
+// 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/slack/location-url.ts
 /** Parse a Slack workspace subdomain used in `https://{domain}.slack.com` URLs. */
 function parseSlackTeamDomain(value) {
@@ -6847,28 +6980,472 @@ async function fetchSlackTeamDomain(teamId) {
 		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);
+/** 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/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/chat/pi/sql-model-usage.ts
+/** SQL reporting adapter for usage stored on assistant history events. */
+const message = sql`${juniorConversationEvents.payload}`;
+const usage$1 = sql`${message}->'usage'`;
+const cost = sql`${usage$1}->'cost'`;
+function nonnegativeNumber(source, field, fallbackField, floor = false) {
+	const value = (name) => sql`case
+      when jsonb_typeof(${source}->${name}) = 'number'
+        and (${source}->>${name})::numeric >= 0
+      then ${floor ? sql`floor((${source}->>${name})::numeric)` : sql`(${source}->>${name})::numeric`}
+    end`;
+	const primary = value(field);
+	return fallbackField ? sql`coalesce(${primary}, ${value(fallbackField)})` : sql`${primary}`;
+}
+function token(field, fallbackField) {
+	return nonnegativeNumber(usage$1, field, fallbackField, true);
+}
+function summed(value) {
+	return sql`sum(${value})::double precision`;
+}
+function summedCost(value) {
+	return sql`round(sum(${value}), 12)::double precision`;
+}
+function messageTotalTokens(args) {
+	const { input, output, cacheRead, cacheWrite } = args;
+	return sql`case
+    when ${input} is not null
+      or ${output} is not null
+      or ${cacheRead} is not null
+      or ${cacheWrite} is not null
+    then coalesce(${input}, 0)
+      + coalesce(${output}, 0)
+      + coalesce(${cacheRead}, 0)
+      + coalesce(${cacheWrite}, 0)
+    else ${token("totalTokens")}
+  end`;
+}
+function definedNumber(value) {
+	return value === null ? void 0 : value;
+}
+function usageFromRow(row) {
+	const components = {
+		inputTokens: definedNumber(row.inputTokens),
+		outputTokens: definedNumber(row.outputTokens),
+		cachedInputTokens: definedNumber(row.cachedInputTokens),
+		cacheCreationTokens: definedNumber(row.cacheCreationTokens)
+	};
+	const costFields = {
+		input: definedNumber(row.costInput),
+		output: definedNumber(row.costOutput),
+		cacheRead: definedNumber(row.costCacheRead),
+		cacheWrite: definedNumber(row.costCacheWrite),
+		total: definedNumber(row.costTotal)
+	};
+	const definedCost = Object.fromEntries(Object.entries(costFields).filter(([, value]) => value !== void 0));
+	const result = {
+		...Object.fromEntries(Object.entries(components).filter(([, value]) => value !== void 0)),
+		...row.reasoningTokens === null ? void 0 : { reasoningTokens: row.reasoningTokens },
+		...row.totalTokens === null ? void 0 : { totalTokens: row.totalTokens },
+		...Object.keys(definedCost).length > 0 ? { cost: definedCost } : void 0
+	};
+	return hasAgentTurnUsage(result) ? agentTurnUsageSchema.parse(result) : void 0;
+}
+/**
+* Aggregate real assistant calls by provider/model in SQL, for one
+* Conversation and all its child agents at any depth. Replayed history is not
+* another call; its tokens appear in the next call's input usage.
+*/
+async function readConversationModelUsageFromSql(executor, options) {
+	const modelId = sql`case
+    when position('/' in coalesce(${message}->>'model', '')) > 0
+      then ${message}->>'model'
+    else concat(${message}->>'provider', '/', ${message}->>'model')
+  end`;
+	const inputTokens = token("input", "inputTokens");
+	const outputTokens = token("output", "outputTokens");
+	const cachedInputTokens = token("cacheRead", "cachedInputTokens");
+	const cacheCreationTokens = token("cacheWrite", "cacheCreationTokens");
+	return (await executor.db().select({
+		modelId,
+		inputTokens: summed(inputTokens),
+		outputTokens: summed(outputTokens),
+		cachedInputTokens: summed(cachedInputTokens),
+		cacheCreationTokens: summed(cacheCreationTokens),
+		reasoningTokens: summed(token("reasoning", "reasoningTokens")),
+		totalTokens: summed(messageTotalTokens({
+			input: inputTokens,
+			output: outputTokens,
+			cacheRead: cachedInputTokens,
+			cacheWrite: cacheCreationTokens
+		})),
+		costInput: summedCost(nonnegativeNumber(cost, "input")),
+		costOutput: summedCost(nonnegativeNumber(cost, "output")),
+		costCacheRead: summedCost(nonnegativeNumber(cost, "cacheRead")),
+		costCacheWrite: summedCost(nonnegativeNumber(cost, "cacheWrite")),
+		costTotal: summedCost(nonnegativeNumber(cost, "total"))
+	}).from(juniorConversationEvents).innerJoin(conversationSubtree([options.conversationId]), eq(conversationSubtreeColumns.conversationId, juniorConversationEvents.conversationId)).where(and(eq(juniorConversationEvents.type, "assistant_message"), notCopiedByFork(), notInheritedByForkChild(), sql`jsonb_typeof(${message}->'provider') = 'string'`, sql`jsonb_typeof(${message}->'model') = 'string'`, sql`coalesce(${message}->>'provider', '') <> ''`, sql`coalesce(${message}->>'model', '') <> ''`)).groupBy(modelId).orderBy(modelId)).flatMap((row) => {
+		const modelUsage = usageFromRow(row);
+		return modelUsage ? [{
+			modelId: row.modelId,
+			usage: modelUsage
+		}] : [];
+	});
+}
+// src/api/conversations/cursor.ts
+const CURSOR_CONTEXT = "junior-conversation-report-cursor";
+const conversationCursorPayloadSchema = z.object({
+	conversationId: z.string().min(1),
+	seq: z.number().int().min(-1),
+	version: z.literal(1)
+}).strict();
+function cursorSecret() {
+	const secret = process.env.JUNIOR_SECRET?.trim();
+	if (!secret) throw new Error("Cannot sign conversation cursor without JUNIOR_SECRET");
+	return secret;
+}
+/** Sign one encoded cursor with the domain-separated server secret. */
+function signature(payload) {
+	return createHmac("sha256", cursorSecret()).update(`${CURSOR_CONTEXT}:${payload}`).digest("base64url");
+}
+/** Encode an authenticated, conversation-bound event position for an API cursor. */
+function encodeConversationCursor(payload) {
+	const encoded = Buffer.from(JSON.stringify({
+		...payload,
+		version: 1
+	}), "utf8").toString("base64url");
+	return `${encoded}.${signature(encoded)}`;
+}
+/** Decode an authenticated reporting cursor for the expected conversation. */
+function decodeConversationCursor(args) {
+	const [encoded, actualSignature, extra] = args.cursor.split(".");
+	if (!encoded || !actualSignature || extra !== void 0) return void 0;
+	const expected = Buffer.from(signature(encoded));
+	const actual = Buffer.from(actualSignature);
+	if (expected.length !== actual.length || !timingSafeEqual(expected, actual)) return;
+	try {
+		const parsed = conversationCursorPayloadSchema.parse(JSON.parse(Buffer.from(encoded, "base64url").toString("utf8")));
+		if (parsed.conversationId !== args.conversationId) return;
+		return { seq: parsed.seq };
+	} catch {
+		return;
+	}
+}
+// 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)
 	});
-	teamDomainInflight.set(parsedTeamId, lookup);
-	return lookup;
+	const mentions = await resolveMentions(executor, sources);
+	return {
+		briefMentions: content.brief ? mentions.at(-1) : [],
+		events: content.events.map((event, index) => withMentions(event, mentions[index]))
+	};
 }
-/** 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));
+/** 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/shared.ts
 /** Format a Slack destination without exposing private channel names. */
@@ -7133,155 +7710,6 @@ function childAgentTotalsReport(metrics, auxiliaryCosts) {
 		...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
@@ -7331,66 +7759,16 @@ async function readConversationAuxiliaryCostsFromSql(db, conversationIds) {
 			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)
-			});
-		}
+		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 selected;
+	return result;
 }
 // src/chat/plugins/unfinished-work.ts
 /**
@@ -7505,158 +7883,6 @@ async function readConversationActivityPreviews(db, conversationIds) {
 		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 = {
 	avatarUrl: juniorIdentities.avatarUrl,
@@ -7684,9 +7910,10 @@ function participantIdentity(row, userAvatarUrls) {
 	};
 	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();
+function participantKey(row) {
+	return row.userId ? `user:${row.userId}` : `identity:${row.identityId}`;
+}
+async function readParticipantRows(db, conversationIds) {
 	const [rootRows, eventRows] = await Promise.all([db.select({
 		conversationId: juniorConversations.conversationId,
 		...identityColumns
@@ -7695,25 +7922,49 @@ async function readConversationParticipants(db, conversationIds) {
 		seq: juniorConversationEvents.seq,
 		...identityColumns
 	}).from(juniorConversationEvents).innerJoin(juniorIdentities, eq(juniorIdentities.id, juniorConversationEvents.actorIdentityId)).leftJoin(juniorUsers, eq(juniorUsers.id, juniorIdentities.userId)).innerJoin(juniorConversations, eq(juniorConversations.conversationId, juniorConversationEvents.conversationId)).innerJoin(juniorConversationParticipants, and(eq(juniorConversationParticipants.userId, juniorIdentities.userId), eq(juniorConversationParticipants.rootConversationId, sql`coalesce(${juniorConversations.rootConversationId}, ${juniorConversations.conversationId})`))).where(inArray(juniorConversationEvents.conversationId, [...conversationIds])).orderBy(asc(juniorConversationEvents.conversationId), asc(juniorConversationEvents.actorIdentityId), asc(juniorConversationEvents.seq))]);
-	const userAvatarUrls = await readUserAvatarUrls(db, [...rootRows, ...eventRows].flatMap((row) => row.userId ? [row.userId] : []));
-	const ordered = /* @__PURE__ */ new Map();
-	const add = (conversationId, row) => {
+	return [...rootRows, ...eventRows.sort((left, right) => left.seq - right.seq)];
+}
+async function groupParticipants(db, rows) {
+	const userAvatarUrls = await readUserAvatarUrls(db, rows.flatMap((row) => row.userId ? [row.userId] : []));
+	const groups = /* @__PURE__ */ new Map();
+	for (const row of rows) {
 		const participant = participantIdentity(row, userAvatarUrls);
-		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);
+		if (!participant) continue;
+		const group = groups.get(row.conversationId) ?? /* @__PURE__ */ new Map();
+		const key = participantKey(row);
+		if (!group.has(key)) group.set(key, participant);
+		groups.set(row.conversationId, group);
+	}
+	return groups;
+}
+/** Read actor identities in first-appearance order for each Conversation. */
+async function readConversationParticipants(db, conversationIds) {
+	if (conversationIds.length === 0) return /* @__PURE__ */ new Map();
+	const groups = await groupParticipants(db, await readParticipantRows(db, conversationIds));
+	return new Map([...groups].map(([conversationId, group]) => [conversationId, [...group.values()]]));
+}
+/**
+* Read the participants of one Conversation, and each of them by each of
+* their Identity ids. A person is listed under every Identity of their
+* user, so a pending Message from another provider resolves too.
+*/
+async function readConversationAuthors(db, conversationId) {
+	const rows = await readParticipantRows(db, [conversationId]);
+	const userIds = [...new Set(rows.flatMap((row) => row.userId ? [row.userId] : []))];
+	const [groups, userIdentities] = await Promise.all([groupParticipants(db, rows), userIds.length > 0 ? db.select({
+		identityId: juniorIdentities.id,
+		userId: juniorIdentities.userId
+	}).from(juniorIdentities).where(inArray(juniorIdentities.userId, userIds)) : []]);
+	const group = groups.get(conversationId) ?? /* @__PURE__ */ new Map();
+	const authors = {};
+	for (const row of [...rows, ...userIdentities]) {
+		const participant = group.get(participantKey(row));
+		if (participant) authors[row.identityId] = participant;
+	}
+	return {
+		authors,
+		participants: [...group.values()]
 	};
-	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;
@@ -7928,4 +8179,317 @@ async function readConversationFeedFromSql(options = {}) {
 async function readConversationFeed(options = {}) {
 	return conversationFeedSchema.parse(await readConversationFeedFromSql(options));
 }
-export { stopSlackThread as A, actOnReviewItem as B, isAllowedSignInEmail as C, buildSlackInboundMessage as D, recordSkippedConversationMessage as E, bindMessageAuthorIdentityId as F, AGENT_DISPATCH_MAX_AGE_MS as G, readReviewItemForUser as H, startProcessingReaction as I, readHealthReport as J, enqueueAgentDispatch as K, stripLeadingBotMention as L, withNormalizedThreadId as M, stopConversationTurn as N, clearSlackPendingReactions as O, THREAD_OPTOUT_ACK as P, parseContent as R, isAllowedDomain as S, resolveAllowedDomains as T, reviewItemChange as U, closeReviewItemsAnsweredByReply as V, getAttachmentStorage as W, createProductionConversationWorkOptions as _, resolveMentions as a, createSlackWebApiStatusSender as b, readConversationAuxiliaryCostsFromSql as c, notCopiedByFork as d, childAgentTotalsReport as f, resolveSlackTeamDomains as g, conversationSummaryFromStoredConversation as h, attachConversationMentions as i, normalizeIncomingSlackThreadId as j, isSlackMessageStopped as k, ConversationForkError as l, conversationEventHistory as m, readConversationRecordFromSql as n, readFirstHumanMessageTexts as o, readConversationTreeMetricsFromSql as p, GET as q, readConversationParticipants as r, listConversationSidebarAnnotations as s, readConversationFeed as t, forkConversation as u, createProductionSlackWebhookServices as v, readEnvList as w, assertNoLegacyAllowedDomains as x, getProductionSlackAdapter as y, ReviewItemActionError as z };
+// src/api/conversations/fork.ts
+/** Fork a Conversation that the viewer can read into a new root they own. */
+async function forkConversationForViewer(viewer, sourceConversationId, body) {
+	if (!(await readConversationAccessFromSql(getDb(), [sourceConversationId], viewer)).get(sourceConversationId)?.canViewPrivateContent) throwApiError(403, "You do not have access to this conversation.");
+	try {
+		return await forkConversation({
+			sourceConversationId,
+			...body,
+			actorEmail: viewer.email,
+			...viewer.displayName ? { actorName: viewer.displayName } : void 0
+		});
+	} catch (error) {
+		if (error instanceof ConversationForkError) throwApiError(409, error.message);
+		throw error;
+	}
+}
+/**
+* Read fork state for the viewer: whether they can fork, and the source and
+* fork links that they can open.
+*/
+async function readConversationForks(conversationId, viewer) {
+	const db = getDb();
+	const [row] = await db.select({
+		forkedFrom: juniorConversations.forkedFromConversationId,
+		parent: juniorConversations.parentConversationId
+	}).from(juniorConversations).where(eq(juniorConversations.conversationId, conversationId));
+	const forks = await db.select({ conversationId: juniorConversations.conversationId }).from(juniorConversations).where(eq(juniorConversations.forkedFromConversationId, conversationId)).orderBy(asc(juniorConversations.createdAt)).limit(50);
+	const forkedFrom = row?.forkedFrom ?? void 0;
+	const ids = forks.map((fork) => fork.conversationId);
+	const access = await readConversationAccessFromSql(db, [
+		conversationId,
+		...ids,
+		...forkedFrom ? [forkedFrom] : []
+	], viewer);
+	const canOpen = (id) => access.get(id)?.canViewPrivateContent;
+	if (!canOpen(conversationId)) return {
+		canFork: false,
+		forks: []
+	};
+	const result = {
+		canFork: !row?.parent,
+		forks: ids.filter(canOpen)
+	};
+	if (forkedFrom && canOpen(forkedFrom)) {
+		const [source] = await db.select({ title: juniorConversations.title }).from(juniorConversations).where(eq(juniorConversations.conversationId, forkedFrom));
+		if (source) {
+			result.forkedFromConversationId = forkedFrom;
+			if (source.title) result.forkedFromTitle = source.title;
+		}
+	}
+	return result;
+}
+// src/api/conversations/agent-tree.ts
+/** Bound the parent chain that one agent tree reads. */
+const MAX_AGENT_TREE_DEPTH = 16;
+const CHILD_LABEL = "Subagent";
+async function readParentConversationId(conversationId) {
+	const [row] = await getDb().select({ parentId: juniorConversations.parentConversationId }).from(juniorConversations).where(eq(juniorConversations.conversationId, conversationId));
+	return row?.parentId ?? void 0;
+}
+/**
+* Read the agent tree of a child Conversation: its parent chain, root first,
+* with the child last. Returns undefined for a root Conversation. Each
+* Conversation has its own access check, so a viewer sees a label only where
+* they can see private content.
+*/
+async function readConversationAgentTree(conversationId, viewer) {
+	const ids = [conversationId];
+	let parentId = await readParentConversationId(conversationId);
+	while (parentId && !ids.includes(parentId) && ids.length < MAX_AGENT_TREE_DEPTH) {
+		ids.unshift(parentId);
+		parentId = await readParentConversationId(parentId);
+	}
+	if (ids.length < 2) return;
+	const root = parentId ? void 0 : await getConversationStore().get({ conversationId: ids[0] });
+	const [access, automationTitleByConversation, firstHumanMessageTextByConversation] = await Promise.all([
+		readConversationAccessFromSql(getDb(), ids, viewer),
+		readAutomationTitlesByConversationId(root ? [root] : []),
+		readFirstHumanMessageTexts(getDb(), root ? [root] : [])
+	]);
+	return await Promise.all(ids.map(async (id) => {
+		const itemAccess = access.get(id);
+		if (root?.conversationId === id) return {
+			conversationId: id,
+			label: conversationSummaryFromStoredConversation({
+				access: itemAccess,
+				automationTitle: automationTitleByConversation.get(id),
+				conversation: root,
+				durationMs: 0,
+				firstHumanMessageText: firstHumanMessageTextByConversation.get(id)
+			}).displayTitle
+		};
+		if (!itemAccess?.canViewPrivateContent) return {
+			conversationId: id,
+			label: CHILD_LABEL
+		};
+		const agent = await getChildAgentLabel(id);
+		return {
+			conversationId: id,
+			label: agent?.title ?? agent?.agentName ?? CHILD_LABEL
+		};
+	}));
+}
+// src/api/conversations/read-position.ts
+/** Read how far the viewer has read one Conversation, if they have read it. */
+async function readConversationReadPosition(viewer, conversationId) {
+	const [row] = await getDb().select({ lastReadSeq: juniorConversationReadPositions.lastReadSeq }).from(juniorConversationReadPositions).where(and(eq(juniorConversationReadPositions.userId, viewer.id), eq(juniorConversationReadPositions.conversationId, conversationId))).limit(1);
+	return row;
+}
+/**
+* Move the viewer's read position forward.
+*
+* The stored value never goes back, so devices can report in any order. A
+* value past the last event is cut to the last event, so a bad client cannot
+* hide messages that arrive later.
+*/
+async function markConversationRead(viewer, conversationId, body) {
+	const db = getDb();
+	const [conversation] = await db.select({ lastSeq: max(juniorConversationEvents.seq) }).from(juniorConversations).leftJoin(juniorConversationEvents, eq(juniorConversationEvents.conversationId, juniorConversations.conversationId)).where(eq(juniorConversations.conversationId, conversationId)).groupBy(juniorConversations.conversationId);
+	if (!conversation) throwApiError(404, "Conversation not found.");
+	const [row] = await db.insert(juniorConversationReadPositions).values({
+		conversationId,
+		lastReadSeq: Math.min(body.lastReadSeq, conversation.lastSeq ?? 0),
+		updatedAt: /* @__PURE__ */ new Date(),
+		userId: viewer.id
+	}).onConflictDoUpdate({
+		target: [juniorConversationReadPositions.userId, juniorConversationReadPositions.conversationId],
+		set: {
+			lastReadSeq: sql`greatest(${juniorConversationReadPositions.lastReadSeq}, excluded.last_read_seq)`,
+			updatedAt: sql`excluded.updated_at`
+		}
+	}).returning({ lastReadSeq: juniorConversationReadPositions.lastReadSeq });
+	return row;
+}
+// src/api/conversations/detail.ts
+/** Project stored metadata and a bounded event page into a signed history cursor. */
+function projectConversationDetail(args) {
+	const { conversation } = args;
+	const conversationId = conversation.conversationId;
+	const transcriptPurgedAtMs = conversation.transcriptPurgedAtMs;
+	const canExposePayload = args.access?.canViewPrivateContent ?? false;
+	const modelUsage = transcriptPurgedAtMs === void 0 ? args.modelUsage : [];
+	const sentryConversationUrl = buildSentryConversationUrl(conversationId);
+	return {
+		...conversationSummaryFromStoredConversation({
+			access: args.access,
+			...args.archivedAtMs === void 0 ? void 0 : { archivedAtMs: args.archivedAtMs },
+			automationTitle: args.automationTitle,
+			auxiliaryCosts: args.auxiliaryCosts,
+			...args.childAgentTotals ? { childAgentTotals: args.childAgentTotals } : void 0,
+			conversation,
+			durationMs: args.durationMs,
+			firstHumanMessageText: args.firstHumanMessageText,
+			...args.locationId ? { locationId: args.locationId } : void 0,
+			...args.teamDomainByTeamId ? { teamDomainByTeamId: args.teamDomainByTeamId } : void 0,
+			usage: args.usage
+		}),
+		annotations: canExposePayload ? args.annotations : [],
+		sidebarAnnotations: canExposePayload ? args.sidebarAnnotations : void 0,
+		...canExposePayload && args.brief ? { brief: args.brief } : void 0,
+		events: args.events,
+		...canExposePayload && args.participants.length > 0 ? {
+			authors: args.authors,
+			participants: args.participants
+		} : void 0,
+		...args.previousSeq !== void 0 ? { previousCursor: encodeConversationCursor({
+			conversationId,
+			seq: args.previousSeq
+		}) } : void 0,
+		...modelUsage.length > 0 ? { modelUsage } : void 0,
+		eventHistory: conversationEventHistory({
+			canExposePayload,
+			...transcriptPurgedAtMs === void 0 ? void 0 : { transcriptPurgedAtMs }
+		}),
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		...sentryConversationUrl ? { sentryConversationUrl } : void 0,
+		...args.sourceTask ? { sourceTask: args.sourceTask } : void 0
+	};
+}
+async function readConversationDetailFromSql(conversationId, options) {
+	const record = await readConversationRecordFromSql(conversationId);
+	if (!record) return void 0;
+	const archivedAtMs = options.viewer ? await readConversationArchivedAt(options.viewer, conversationId) : void 0;
+	const executor = getSqlExecutor();
+	const [accessByConversation, annotations, automationTitleByConversation, auxiliaryCostsByConversation, briefVersion, firstHumanMessageTextByConversation, modelUsage, metricsByConversation, people, sourceTask, teamDomainByTeamId] = await Promise.all([
+		readConversationAccessFromSql(getDb(), [conversationId], options.viewer),
+		listConversationAnnotations(getDb(), conversationId),
+		readAutomationTitlesByConversationId([record.conversation]),
+		readConversationAuxiliaryCostsFromSql(getDb(), [conversationId]),
+		readLatestConversationBrief(getDb(), conversationId),
+		readFirstHumanMessageTexts(getDb(), [record.conversation]),
+		record.conversation.transcriptPurgedAtMs === void 0 ? readConversationModelUsageFromSql(executor, { conversationId }) : Promise.resolve([]),
+		readConversationTreeMetricsFromSql(getDb(), [conversationId]),
+		readConversationAuthors(getDb(), conversationId),
+		readConversationSourceTask({
+			conversationId,
+			...options.viewer ? { viewer: options.viewer } : void 0
+		}),
+		resolveSlackTeamDomains(record.conversation.location?.provider === "slack" ? [record.conversation.location.teamId] : [])
+	]);
+	const access = accessByConversation.get(conversationId);
+	const sidebarAnnotations = access?.canViewPrivateContent ? (await listConversationSidebarAnnotations([conversationId], /* @__PURE__ */ new Map([[conversationId, annotations]])))[conversationId] : void 0;
+	const page = record.conversation.transcriptPurgedAtMs === void 0 ? await readConversationEventPage(executor, {
+		canExposePayload: access?.canViewPrivateContent ?? false,
+		conversationId,
+		limit: options.limit
+	}) : { events: [] };
+	const brief = access?.canViewPrivateContent ? briefVersion?.content : void 0;
+	const { briefMentions, events } = await attachConversationMentions(executor, conversationId, {
+		...brief ? { brief } : void 0,
+		events: page.events
+	});
+	const metrics = metricsByConversation.get(conversationId);
+	const auxiliaryCosts = auxiliaryCostsByConversation.get(conversationId);
+	const childAgentTotals = childAgentTotalsReport(metrics, auxiliaryCosts);
+	return projectConversationDetail({
+		...record,
+		access,
+		...archivedAtMs === void 0 ? void 0 : { archivedAtMs },
+		automationTitle: automationTitleByConversation.get(conversationId),
+		annotations,
+		sidebarAnnotations,
+		auxiliaryCosts: auxiliaryCosts?.total,
+		...childAgentTotals ? { childAgentTotals } : void 0,
+		...briefVersion ? { brief: {
+			content: briefVersion.content,
+			...briefMentions.length > 0 ? { mentions: briefMentions } : void 0,
+			updatedAt: briefVersion.createdAt.toISOString(),
+			version: briefVersion.version
+		} } : void 0,
+		durationMs: metrics?.durationMs ?? record.durationMs,
+		events,
+		firstHumanMessageText: firstHumanMessageTextByConversation.get(conversationId),
+		modelUsage,
+		authors: people.authors,
+		participants: people.participants,
+		...sourceTask ? { sourceTask } : void 0,
+		teamDomainByTeamId,
+		...page.previousSeq === void 0 ? void 0 : { previousSeq: page.previousSeq },
+		usage: metrics?.usage ?? record.usage ?? void 0
+	});
+}
+/** Load one conversation from its canonical event history. */
+async function readConversationDetail(conversationId, options = {}) {
+	const report = await readConversationDetailFromSql(conversationId, {
+		...options,
+		limit: options.limit ?? 500
+	});
+	if (!report) return void 0;
+	const [forks, agentTree, readPosition] = await Promise.all([
+		readConversationForks(conversationId, options.viewer),
+		readConversationAgentTree(conversationId, options.viewer),
+		options.viewer ? readConversationReadPosition(options.viewer, conversationId) : void 0
+	]);
+	return conversationDetailReportSchema.parse({
+		...report,
+		...forks,
+		...agentTree ? { agentTree } : void 0,
+		...readPosition ? { readPosition } : void 0
+	});
+}
+// src/api/conversations/stop.ts
+/**
+* Stop the active Turn for one conversation participant.
+*
+* The stop also removes the human messages queued before it. The viewer's own
+* web text comes back in the response so the dashboard can restore it to the
+* composer instead of losing it.
+*/
+async function stopConversationTurnForViewer(viewer, conversationId, services) {
+	const conversationStore = getConversationStore();
+	if (!await conversationStore.get({ conversationId })) throwApiError(404, "Conversation not found.");
+	if (!(await readConversationAccessFromSql(getDb(), [conversationId], viewer)).get(conversationId)?.isParticipant) throwApiError(403, "Only conversation participants can stop this turn.");
+	try {
+		const result = await stopConversationTurn({
+			conversationId,
+			conversationStore,
+			queue: services.queue
+		});
+		if (result.status === "no_work") return {
+			conversationId,
+			status: "no_work",
+			stoppedInboundMessageIds: [],
+			stoppedMessages: []
+		};
+		await clearSlackPendingReactions({
+			getSlackAdapter: getProductionSlackAdapter,
+			messages: result.pendingMessages
+		});
+		return {
+			conversationId,
+			status: "requested",
+			stoppedInboundMessageIds: result.pendingMessages.map((message) => message.inboundMessageId),
+			stoppedMessages: viewerWebMessages(result.pendingMessages, viewer)
+		};
+	} catch (error) {
+		throwApiError(500, "Unable to stop the active turn.", error);
+	}
+}
+function viewerWebMessages(messages, viewer) {
+	const viewerUserId = webActorFromEmail(viewer.email).userId;
+	return messages.flatMap((message) => {
+		if (message.source !== "web") return [];
+		const metadata = legacyWebMailboxMetadataSchema.safeParse(message.input.metadata);
+		if (!metadata.success) return [];
+		if (metadata.data.authorUserId !== viewerUserId) return [];
+		const text = message.input.text.trim();
+		return text ? [{
+			inboundMessageId: message.inboundMessageId,
+			text
+		}] : [];
+	});
+}
+export { recordSkippedConversationMessage as A, startProcessingReaction as B, getProductionSlackAdapter as C, isAllowedSignInEmail as D, isAllowedDomain as E, normalizeIncomingSlackThreadId as F, closeReviewItemsAnsweredByReply as G, parseContent as H, withNormalizedThreadId as I, getAttachmentStorage as J, readReviewItemForUser as K, stopConversationTurn as L, clearSlackPendingReactions as M, isSlackMessageStopped as N, readEnvList as O, stopSlackThread as P, readHealthReport as Q, THREAD_OPTOUT_ACK as R, createProductionSlackWebhookServices as S, assertNoLegacyAllowedDomains as T, ReviewItemActionError as U, stripLeadingBotMention as V, actOnReviewItem as W, enqueueAgentDispatch as X, AGENT_DISPATCH_MAX_AGE_MS as Y, GET as Z, archiveConversation as _, readConversationFeed as a, throwApiError as b, childAgentTotalsReport as c, conversationSummaryFromStoredConversation as d, attachConversationMentions as f, encodeConversationCursor as g, decodeConversationCursor as h, forkConversationForViewer as i, buildSlackInboundMessage as j, resolveAllowedDomains as k, readConversationTreeMetricsFromSql as l, readFirstHumanMessageTexts as m, readConversationDetail as n, readConversationRecordFromSql as o, resolveMentions as p, reviewItemChange as q, markConversationRead as r, readConversationAuxiliaryCostsFromSql as s, stopConversationTurnForViewer as t, conversationEventHistory as u, emptyResponse as v, createSlackWebApiStatusSender as w, createProductionConversationWorkOptions as x, jsonResponse as y, bindMessageAuthorIdentityId as z };