@sentry/junior 0.267.0 → 0.269.0

package/dist/{tasks-0ilmuCux.js → turn-session-routing-BqO0qXLk.js}

@@ -1,22 +1,23 @@
-import { a as completeText, f as unwrapCurrentInstruction, p as escapeXml, s as resolveGatewayModel, y as isProviderRetryError } from "./client-BjgbMawj.js";
-import { i as getChatConfig, n as botConfig } from "./config-CdB6yJj5.js";
-import { B as isRecord, H as toOptionalString, V as toOptionalNumber, b as setSpanAttributes, h as logWarn, o as getActiveTraceContext, p as logException, t as buildTurnFailureResponse } from "./logging-DuZ1A4ab.js";
-import { c as toStoredSlackActor, p as parseSlackMessageTs, s as parseStoredSlackActor } from "./actor-DZSokpwj.js";
-import { B as parseDestination, C as bindProviderConversation, H as sameDestination, T as addAgentTurnUsage, f as getConversationStore, g as withConversationEventLock, h as createSqlConversationEventStore, m as getSqlExecutor, p as getDb, u as getConversationEventStore, x as startLocationThread } from "./viewer-DrN3oC2X.js";
-import { d as juniorDestinations } from "./agent-invocations-CxKldAeB.js";
-import { a as juniorAutomationRuns, l as juniorLocationConfigurations, o as juniorAutomationVersions, s as juniorAutomations } from "./executor-VYrx_K4w.js";
-import { d as contextProvenance, f as instructionActors, n as agentHistoryItemSchema, p as instructionProvenanceFor } from "./history-C84mlAwO.js";
-import { f as credentialContextForActor, h as credentialSubjectSchema } from "./registry-FQutO926.js";
-import { n as pluginCatalogRuntime } from "./catalog-runtime-cMlAI5LY.js";
-import { H as startOAuthFlow, Nn as createPluginLogger, St as resolveSandboxEgressProviderForHost, ar as createPluginCache, cn as sleep$1, cr as agentsInstructionsUpdatedEvent, dn as JUNIOR_THREAD_STATE_TTL_MS, gn as ToolInputError, lr as authenticationLinkedEvent, p as getPlugins, sr as JUNIOR_NATIVE_EVENT_NAMESPACE, t as executeCredentialedEgressRequest, ur as authenticationUnlinkedEvent, vt as parseSandboxEgressAuthRequiredSignal, z as formatProviderLabel } from "./credentialed-CIGwoLU2.js";
-import { a as MUTATION_LOCK_TTL_MS, c as withLock, i as getStateAdapter, r as getDefaultRedisStateAdapterFor, s as fenceLock } from "./adapter-BybMEezj.js";
-import { L as messageCardRef } from "./conversation-DSo310Ps.js";
-import { A as eventAutomationSchema, E as scheduledAutomationSchema, S as automationVersionSchema } from "./automation-CmeFBSEh.js";
+import { a as completeText, f as unwrapCurrentInstruction, p as escapeXml, s as resolveGatewayModel, y as isProviderRetryError } from "./client-Cqf4TboL.js";
+import { i as getChatConfig, n as botConfig } from "./config-CPsE4T5L.js";
+import { B as isRecord, E as withSpan, H as toOptionalString, V as toOptionalNumber, _ as runBestEffort, b as setSpanAttributes, h as logWarn, o as getActiveTraceContext, p as logException, t as buildTurnFailureResponse } from "./logging-n7knse-O.js";
+import { c as parseStoredSlackActor, l as toStoredSlackActor, m as parseSlackMessageTs } from "./actor-CP9K2Idu.js";
+import { A as startLocationThread, C as getSqlExecutor, G as agentTurnTotalTokens, M as resolveActorIdentityId, Q as sameDestination, S as getDb, T as withConversationEventLock, U as addAgentTurnUsage, V as bindProviderConversation, W as agentTurnCostUsd, X as parseDestination, w as createSqlConversationEventStore, x as getConversationStore, y as getConversationEventStore } from "./viewer-DSbD6DF6.js";
+import { d as juniorDestinations, s as juniorConversations } from "./agent-invocations-C1RNOCs8.js";
+import { d as juniorAutomations, l as juniorAutomationRuns, p as juniorLocationConfigurations, u as juniorAutomationVersions } from "./executor-CNS7ONt-.js";
+import { a as agentHistoryItemSchema, g as instructionProvenanceFor, h as instructionActors, m as contextProvenance } from "./media-85PDJxO_.js";
+import { f as credentialContextForActor, h as credentialSubjectSchema } from "./registry-By36_xsm.js";
+import { n as pluginCatalogRuntime } from "./catalog-runtime-BsoSmTM0.js";
+import { Bn as getDashboardTaskLink, Ct as openSlackDirectMessage, Et as postSlackMessage, Fr as authenticationUnlinkedEvent, Gt as parseSandboxEgressAuthRequiredSignal, Hn as ToolInputError, In as JUNIOR_THREAD_STATE_TTL_MS, Mr as JUNIOR_NATIVE_EVENT_NAMESPACE, Nn as sleep$1, Nr as agentsInstructionsUpdatedEvent, Pr as authenticationLinkedEvent, Yt as resolveSandboxEgressProviderForHost, ar as createPluginLogger, ht as formatSlackLink, jr as createPluginCache, mt as escapeSlackMrkdwnText, p as getPlugins, pt as startOAuthFlow, t as executeCredentialedEgressRequest, ut as formatProviderLabel } from "./credentialed-BU-OW7HP.js";
+import { a as withLock, i as fenceLock, n as MUTATION_LOCK_TTL_MS } from "./locks-D-0h111u.js";
+import { n as getDefaultRedisStateAdapterFor, r as getStateAdapter } from "./adapter-2-CG25be.js";
+import { L as messageCardRef } from "./conversation-CTpD_PGk.js";
+import { O as eventAutomationSchema, S as automationVersionSchema, j as scheduledAutomationSchema } from "./automation-p87hg_AV.js";
 import { isDeepStrictEqual } from "node:util";
 import { z } from "zod";
 import { createHash, randomUUID } from "node:crypto";
-import { and, asc, desc, eq, inArray, isNull, ne, or, sql } from "drizzle-orm";
-import { actorSchema, anyResourceMatchFields, describeEventTrigger, destinationSchema, eventMatchSchema, eventMatches, eventTriggerChoices, eventTriggerProblems, normalizeEventIdentifier, normalizeEventMatch, sourceSchema } from "@sentry/junior-plugin-api";
+import { and, asc, count, desc, eq, gte, inArray, isNotNull, isNull, lte, max, ne, or, sql } from "drizzle-orm";
+import { actorSchema, anyResourceMatchFields, describeEventTrigger, destinationSchema, destinationVisibilitySchema, eventMatchSchema, eventMatches, eventTriggerChoices, eventTriggerProblems, isSlackDestination, normalizeEventIdentifier, normalizeEventMatch, replyAttributionSchema, sourceSchema, taskOutcomeSchema } from "@sentry/junior-plugin-api";
 // src/chat/configuration/defaults.ts
 let installDefaults = {};
 function cloneDefaults(defaults) {
@@ -401,7 +402,11 @@ function createDurableLocationConfigurationService(args) {
 * Add new keys here as features graduate from private experiments; remove them
 * once they become stable defaults.
 */
-const EXPERIMENTAL_FEATURES = ["operator-tools", "passive-routing"];
+const EXPERIMENTAL_FEATURES = [
+	"operator-tools",
+	"passive-routing",
+	"user-customization"
+];
 const EXPERIMENTAL_FEATURE_SET = new Set(EXPERIMENTAL_FEATURES);
 let configuredExperimental = {};
 function isExperimentalFeature(value) {
@@ -887,7 +892,8 @@ const SESSION_CONTEXT_SECTION_TAG = "runtime";
 const REQUEST_CONTEXT_SECTION_TAG = {
 	pluginContext: "plugin-context",
 	conversationNotes: "conversation-notes",
-	disabledTools: "disabled-tools"
+	disabledTools: "disabled-tools",
+	userCustomization: "user-customization"
 };
 // src/chat/pi/transcript.ts
 const RUNTIME_TURN_CONTEXT_START = `<${TURN_CONTEXT_TAG}>`;
@@ -1158,6 +1164,8 @@ const inboundMessageSourceSchema = z.enum([
 const agentInputSchema = z.object({
 	attachments: z.array(z.unknown()).optional(),
 	authorId: z.string().min(1).optional(),
+	/** Identity of the input author, resolved at ingress. */
+	authorIdentityId: z.string().min(1).optional(),
 	metadata: z.record(z.string(), z.unknown()).optional(),
 	text: z.string()
 }).strict().refine((input) => input.text.trim() || input.attachments?.length, { message: "agent input requires text or attachments" });
@@ -2300,8 +2308,17 @@ async function withTurnCursorMutation(conversationId, turnId, run) {
 	if (!result.acquired) throw new Error(`Could not acquire turn cursor lock for ${turnId}`);
 	return result.value;
 }
-function executionMetricsForTurn(conversation, turnId) {
-	return conversation?.executionMetrics?.runId === turnId ? conversation.executionMetrics : void 0;
+/**
+* Read this Turn's own totals. A newer Turn can own the latest Conversation
+* metrics while this Turn is paused, so fall back to this Turn's metric rows.
+*/
+async function executionMetricsForTurn(conversationStore, conversation, turnId) {
+	if (!conversation) return void 0;
+	if (conversation.executionMetrics?.runId === turnId) return conversation.executionMetrics;
+	return await conversationStore.getRunMetrics({
+		conversationId: conversation.conversationId,
+		runId: turnId
+	});
 }
 /** Keep only keys whose value is defined. */
 function definedProps$1(values) {
@@ -2350,6 +2367,7 @@ const storedTurnSummarySchema = z.object({
 /** Full resume cursor stored for one turn. */
 const storedTurnRecordSchema = z.object({
 	actor: actorSchema.optional(),
+	actorIdentityId: z.string().min(1).optional(),
 	schemaVersion: z.literal(TURN_CURSOR_SCHEMA_VERSION),
 	version: z.number().int().nonnegative(),
 	conversationId: z.string().min(1),
@@ -2472,6 +2490,7 @@ function materializeTurnRecord(stored, piProjection, turnStartMessageIndex, runt
 		actors: instructionActors(piProjection.provenance),
 		cumulativeDurationMs: runtimeMetrics?.cumulativeDurationMs ?? 0,
 		...definedProps$1({
+			actorIdentityId: stored.actorIdentityId,
 			channelName: runtimeMetrics?.channelName,
 			credentialSubject: stored.credentialSubject,
 			cumulativeToolCallCount: stored.cumulativeToolCallCount,
@@ -2513,8 +2532,9 @@ async function materializeStoredTurnRecord(conversationId, turnId, followCurrent
 	const followsReplacement = followCurrentReplacement && (parsed.state === "running" || parsed.state === "paused") && parsed.historyVersion !== void 0 && parsed.historyVersion !== currentHistoryVersion;
 	const piProjection = followsReplacement ? projectConversationEvents(await eventStore.loadCurrentHistory(conversationId), { defaultProfile: botConfig.defaultProfile }) : pinnedProjection;
 	const turnStartMessageIndex = followsReplacement ? 0 : parsed.turnStartSeq === void 0 ? void 0 : piProjection.seqs.filter((seq) => seq <= parsed.turnStartSeq).length;
-	const conversation = await getConversationStore().get({ conversationId });
-	const executionMetrics = executionMetricsForTurn(conversation, turnId);
+	const conversationStore = getConversationStore();
+	const conversation = await conversationStore.get({ conversationId });
+	const executionMetrics = await executionMetricsForTurn(conversationStore, conversation, turnId);
 	return materializeTurnRecord(parsed, piProjection, turnStartMessageIndex, {
 		channelName: conversation?.channelName,
 		cumulativeDurationMs: executionMetrics?.durationMs,
@@ -2545,6 +2565,7 @@ function buildStoredRecord(args) {
 		committedSeq: args.committedSeq,
 		...definedProps$1({
 			actor: args.actor,
+			actorIdentityId: args.actorIdentityId,
 			credentialSubject: args.credentialSubject,
 			cumulativeToolCallCount: args.cumulativeToolCallCount,
 			turnLimitWrappedUp: args.turnLimitWrappedUp,
@@ -2623,6 +2644,7 @@ async function updateTurnState(args) {
 			lastProgressAtMs: parsed.lastProgressAtMs,
 			previousVersion: parsed.version,
 			...definedProps$1({
+				actorIdentityId: args.existing.actorIdentityId,
 				credentialSubject: args.existing.credentialSubject,
 				cumulativeToolCallCount: args.existing.cumulativeToolCallCount,
 				turnLimitWrappedUp: args.existing.turnLimitWrappedUp,
@@ -2649,8 +2671,9 @@ async function upsertTurnRecord(args) {
 }
 async function upsertTurnRecordLocked(args, fence) {
 	const existingRecord = await getStoredTurnRecord(args.conversationId, args.turnId);
-	const conversation = await (args.conversationStore ?? getConversationStore()).get({ conversationId: args.conversationId });
-	const executionMetrics = executionMetricsForTurn(conversation, args.turnId);
+	const conversationStore = args.conversationStore ?? getConversationStore();
+	const conversation = await conversationStore.get({ conversationId: args.conversationId });
+	const executionMetrics = await executionMetricsForTurn(conversationStore, conversation, args.turnId);
 	const existingDispatchId = existingRecord?.dispatchId ?? (await listTurnSummaries(args.conversationId)).find((summary) => summary.turnId === args.turnId)?.dispatchId;
 	if (existingDispatchId && args.dispatchId && existingDispatchId !== args.dispatchId) throw new Error(`Turn ${args.turnId} dispatchId cannot be changed`);
 	const ttlMs = turnCursorTtlMs(args.state, args.ttlMs);
@@ -2672,8 +2695,10 @@ async function upsertTurnRecordLocked(args, fence) {
 	const dispatchId = args.dispatchId ?? existingRecord?.dispatchId;
 	const hasProviderLocation = Boolean(conversation?.location) || args.destination?.platform === "slack";
 	const publishExternally = dispatchId || turnSource ? hasProviderLocation && (Boolean(dispatchId) || turnSource?.kind === "slack" || turnSource?.kind === "event") : existingRecord?.publishExternally ?? false;
+	const turnActor = existingRecord?.actor ?? args.actor;
+	const actorIdentityId = existingRecord?.actorIdentityId ?? (turnActor ? await resolveActorIdentityId(getSqlExecutor(), turnActor) : void 0);
 	return await setStoredRecord({
-		actor: existingRecord?.actor ?? args.actor,
+		actor: turnActor,
 		fence,
 		conversationStore: args.conversationStore,
 		destination: args.destination,
@@ -2690,7 +2715,7 @@ async function upsertTurnRecordLocked(args, fence) {
 		...definedProps$1({ indexTtlMs: args.ttlMs }),
 		turnStartMessageIndex,
 		record: buildStoredRecord({
-			actor: existingRecord?.actor ?? args.actor,
+			actor: turnActor,
 			conversationId: args.conversationId,
 			turnId: args.turnId,
 			sliceId: args.sliceId,
@@ -2699,6 +2724,7 @@ async function upsertTurnRecordLocked(args, fence) {
 			historyVersion: commit.historyVersion,
 			previousVersion: existingRecord?.version,
 			...definedProps$1({
+				actorIdentityId,
 				credentialSubject: existingRecord?.credentialSubject ?? args.credentialSubject,
 				cumulativeToolCallCount: args.cumulativeToolCallCount ?? existingRecord?.cumulativeToolCallCount,
 				turnLimitWrappedUp: args.turnLimitWrappedUp ?? existingRecord?.turnLimitWrappedUp,
@@ -2728,7 +2754,7 @@ async function recordTurnSummaryOwned(args, fence) {
 	const stored = await getStoredTurnRecord(args.conversationId, args.turnId);
 	const conversationStore = args.conversationStore ?? getConversationStore();
 	const conversation = await conversationStore.get({ conversationId: args.conversationId });
-	const executionMetrics = executionMetricsForTurn(conversation, args.turnId);
+	const executionMetrics = await executionMetricsForTurn(conversationStore, conversation, args.turnId);
 	const priorSummary = (await listTurnSummaries(args.conversationId)).find((summary) => summary.turnId === args.turnId);
 	const terminalSummary = priorSummary && (priorSummary.state === "completed" || priorSummary.state === "failed" || priorSummary.state === "abandoned") ? priorSummary : void 0;
 	const terminalRecord = stored && (stored.state === "completed" || stored.state === "failed" || stored.state === "abandoned") ? stored : void 0;
@@ -2866,11 +2892,14 @@ async function loadTurnCheckpoint(args) {
 	};
 }
 async function saveTurnCheckpoint(args) {
-	if (args.mode === "running") return await saveRunning(args);
-	if (args.mode === "paused") return await savePaused(args);
-	await saveDone(args);
-}
-function sharedWrite(args, latest) {
+	const traceContext = getActiveTraceContext();
+	return await withSpan("turn.checkpoint.save", "turn.checkpoint.save", {}, async () => {
+		if (args.mode === "running") return await saveRunning(args, traceContext);
+		if (args.mode === "paused") return await savePaused(args, traceContext);
+		await saveDone(args, traceContext);
+	}, { "app.turn.checkpoint.mode": args.mode });
+}
+function sharedWrite(args, traceContext, latest) {
 	return {
 		conversationId: args.conversationId,
 		turnId: args.turnId,
@@ -2883,7 +2912,7 @@ function sharedWrite(args, latest) {
 			dispatchId: args.dispatchId ?? latest?.dispatchId,
 			source: args.source,
 			surface: args.surface ?? latest?.surface,
-			traceContext: latest?.traceContext ?? getActiveTraceContext(),
+			traceContext: latest?.traceContext ?? traceContext,
 			turnStartMessageIndex: args.turnStartMessageIndex ?? latest?.turnStartMessageIndex,
 			cumulativeToolCallCount: args.cumulativeToolCallCount ?? latest?.cumulativeToolCallCount,
 			turnLimitWrappedUp: args.turnLimitWrappedUp ?? latest?.turnLimitWrappedUp,
@@ -2891,12 +2920,12 @@ function sharedWrite(args, latest) {
 		})
 	};
 }
-async function saveRunning(args) {
+async function saveRunning(args, traceContext) {
 	if (args.messages.length === 0 || !isContinuablePiBoundary(args.messages)) return;
 	try {
 		const latest = await getTurnRecord(args.conversationId, args.turnId);
 		return await upsertTurnRecord({
-			...sharedWrite(args, latest),
+			...sharedWrite(args, traceContext, latest),
 			...definedProps({
 				trailingMessageProvenance: args.trailingMessageProvenance,
 				turnContexts: args.turnContexts
@@ -2916,7 +2945,7 @@ async function saveRunning(args) {
 		return;
 	}
 }
-async function savePaused(args) {
+async function savePaused(args, traceContext) {
 	const keepSlice = args.reason === "yield";
 	const nextSliceId = keepSlice ? args.sliceId : args.sliceId + 1;
 	try {
@@ -2926,7 +2955,7 @@ async function savePaused(args) {
 			if (!args.beforePrompt && messages.length > 0 && !isContinuablePiBoundary(messages)) return;
 		} else if (messages.length === 0 || !isContinuablePiBoundary(messages)) return;
 		const base = {
-			...sharedWrite(args, latest),
+			...sharedWrite(args, traceContext, latest),
 			...definedProps({
 				cumulativeDurationMs: addDurationMs(latest?.cumulativeDurationMs, args.durationMs),
 				cumulativeUsage: addAgentTurnUsage(latest?.cumulativeUsage, args.usage),
@@ -2964,7 +2993,7 @@ async function savePaused(args) {
 		return;
 	}
 }
-async function saveDone(args) {
+async function saveDone(args, traceContext) {
 	let latest;
 	await persistWithRetry(async () => {
 		latest = await getTurnRecord(args.conversationId, args.turnId);
@@ -2973,7 +3002,7 @@ async function saveDone(args) {
 	if (sliceId === void 0) throw new Error("Completed turn checkpoint requires a slice id from the caller or the latest stored record");
 	await persistWithRetry(async () => {
 		await upsertTurnRecord({
-			...sharedWrite(args, latest),
+			...sharedWrite(args, traceContext, latest),
 			...definedProps({
 				cumulativeDurationMs: addDurationMs(latest?.cumulativeDurationMs, args.durationMs),
 				cumulativeUsage: addAgentTurnUsage(latest?.cumulativeUsage, args.usage),
@@ -3828,6 +3857,7 @@ function projectConversationMessages(history) {
 				role: data.role,
 				text: data.text,
 				createdAtMs: event.createdAtMs,
+				...data.authorIdentityId ? { authorIdentityId: data.authorIdentityId } : void 0,
 				...splitMeta(data.meta)
 			};
 			if (data.type === "message" && current) throw new Error(`Duplicate message event for ${data.messageId} at seq ${event.seq}`);
@@ -3876,6 +3906,7 @@ function toStoredConversationMessage(message) {
 		messageId: message.id,
 		role: message.role,
 		text: message.text,
+		...message.authorIdentityId ? { authorIdentityId: message.authorIdentityId } : void 0,
 		...Object.keys(meta).length > 0 ? { meta } : void 0,
 		createdAtMs: message.createdAtMs
 	};
@@ -4868,10 +4899,6 @@ async function deleteEventAutomation(db, id) {
 	const rows = await db.update(juniorAutomations).set({ status: "deleted" }).where(and(eq(juniorAutomations.id, id), activeEventAutomationWhere())).returning();
 	return rows[0] ? parseEventAutomationRow(rows[0]) : void 0;
 }
-/** List live event automations in one Slack workspace. */
-async function listEventAutomationsForTeam(db, teamId) {
-	return (await db.select().from(juniorAutomations).where(and(eq(juniorAutomations.teamId, teamId), activeEventAutomationWhere())).orderBy(asc(juniorAutomations.createdAtMs), asc(juniorAutomations.id))).map(parseEventAutomationRow);
-}
 /**
 * List deleted event automations created by one user, newest first.
 * Used only to keep historical runs after the live automation list drops the row.
@@ -5147,4 +5174,892 @@ async function saveScheduledAutomation(db, task, expectedRevision, editedBy) {
 async function saveScheduledAutomationInLock(db, task, current) {
 	await writeScheduledAutomation(db, requireStoredTask(task), current);
 }
-export { recordAgentsInstructionsUpdated as $, buildDeterministicTurnId as $n, appendExclusiveInboundMessage as $t, CORE_EVENT_NAMESPACE as A, TurnToolCallLimitExceededError as An, PluginCredentialFailureError as At, registeredEventTypeSchema as B, instructionTextForProjection as Bn, wasPendingAuthStopped as Bt, automationVersionOf as C, requestConversationWork as Cn, isHumanConversationMessage as Ct, AutomationConflictError as D, TURN_LIMIT_DISABLED_REASON as Dn, turnHasReply as Dt, sameDefinitionValue as E, stopConversationWork as En, recordDeliveredAssistantMessage as Et, eventNamespaceSchema as F, extractAssistantText as Fn, AuthorizationPauseError as Ft, commitMessages as G, normalizeToolNameFromResult as Gn, completeTurnRecord as Gt, requireEventIdentifier as H, isContinuablePiBoundary as Hn, loadTurnCheckpoint as Ht, eventWatchUnavailable as I, getPiMessageRole as In, abandonReplacedPendingAuth as It, loadLastModelProfile as J, trimTrailingAssistantMessages as Jn, listTurnSummaries as Jt, loadConnectedMcpProviders as K, retainRuntimeTurnContext as Kn, failTurnRecord as Kt, hasEventCatalogEntries as L, getTerminalAssistantMessages as Ln, canReusePendingAuthLink as Lt, describeRegisteredEventTrigger as M, createTurnLimitGate as Mn, authorizationId as Mt, eventCatalogEntry as N, isTurnExecutionLimitExceededError as Nn, AuthPausePersistenceError as Nt, automationRevision as O, TurnBudgetExceededError as On, upsertConversationMessage as Ot, eventGuidance as P, persistWithRetry as Pn, AuthorizationFlowDisabledError as Pt, openConversationProjection as Q, buildDeterministicAssistantMessageId as Qn, ackMessages as Qt, registeredEventMatchSchema as R, getUserMessageInstructionText as Rn, clearPendingAuth as Rt, automationDefinition as S, requestAnotherSlice as Sn, getConversationMessageSlackTs as St, readAutomationVersion as T, steerWebPendingMessages as Tn, normalizeConversationText as Tt, requireValidEventTrigger as U, isToolResultError as Un, saveTurnCheckpoint as Ut, registeredResourceTypeSchema as V, isAssistantMessage as Vn, continuableMessages as Vt, commitAcceptedReply as W, isToolResultMessage as Wn, abandonTurnRecord as Wt, loadTurnProjection as X, SESSION_CONTEXT_SECTION_TAG as Xn, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS as Xt, loadProjection as Y, REQUEST_CONTEXT_SECTION_TAG as Yn, recordTurnSummary as Yt, loadTurnRoute as Z, TURN_CONTEXT_TAG as Zn, CONVERSATION_WORK_STALE_ENQUEUE_MS as Zt, parseEventAutomationRow as _, markConversationWorkEnqueued as _n, resolveTaskTitle as _t, saveScheduledAutomation as a, clearExpiredConversationLease as an, getAgentContextCompactionTriggerTokens as ar, recordMcpProviderConnected as at, admitEventAutomationRun as b, releaseConversationWork as bn, createConversationMemoryService as bt, withScheduledAutomationLock as c, deadLetterAttempt as cn, isExperimentalFeatureEnabled as cr, recordTurnRoute as ct, createEventAutomation as d, getConversationWorkState as dn, configValueSchema as dr, persistConversationMessages as dt, appendInboundMessage as en, SubscribedReplyReason as er, recordAttachmentsDelivered as et, deleteEventAutomation as f, hasConversationStop as fn, historyItemFromPiMessage as fr, projectConversationMessages as ft, listEventAutomationsForTeam as g, listActiveConversationIds as gn, fallbackShortTitle as gt, listDeletedEventAutomationsCreatedBy as h, isInvalidConversationRecordError as hn, setConfigDefaults as hr, settleConversationTitleWork as ht, readScheduledAutomation as i, clearConsumedConversationWake as in, estimateTextTokens as ir, recordGuardianActionReviewed as it, automationEventCatalog as j, buildTurnErrorResponse as jn, createPluginAuthOrchestration as jt, requireAutomationRevision as k, TurnSliceLimitExceededError as kn, createPluginEgress as kt, blockEventAutomation as l, drainConversationMailbox as ln, setExperimentalFeatures as lr, appendConversationMessages as lt, getEventAutomation as m, isFinalAttempt as mn, getConfigDefaults as mr, resolveConversationTitle as mt, listScheduledAutomationsForTeam as n, cancelHumanFacingPendingMessages as nn, getSubscribedReplyPreflightDecision as nr, recordAuthorizationCompleted as nt, saveScheduledAutomationInLock as o, completeConversationStop as on, getAgentContextInputLimitTokens as or, recordSubscribedReplyRoute as ot, findMatchingEventAutomations as p, hasRunnableConversationWork as pn, piMessageFromHistoryItem as pr, persistConversationMessageSummaries as pt, loadConversationProjection as q, stripRuntimeTurnContext as qn, getTurnRecord as qt, parseScheduledAutomationRow as r, checkInConversationWork as rn, getThreadStopDecision as rr, recordAuthorizationRequested as rt, scheduledRunId as s, completeConversationWork as sn, getExperimentalFeatures as sr, recordToolExecutionStarted as st, createScheduledAutomation as t, beginConversationResume as tn, decideSubscribedThreadReply as tr, recordAuthenticationLinked as tt, collectEventAutomationMatchKeys as u, getConversation as un, createDurableLocationConfigurationService as ur, hydrateConversationMessages as ut, saveEventAutomation as v, recordAttemptFailure as vn, appendThreadContextMessages as vt, listAutomationVersions as w, startConversationWork as wn, markConversationMessage as wt, eventAutomationRunLimitReason as x, removeActiveConversation as xn, estimateConversationContextTokens as xt, setEventAutomationStatus as y, recordConversationRetry as yn, buildConversationContext as yt, registeredEventTriggerProblems as z, hasRuntimeTurnContext as zn, getConversationPendingAuth as zt };
+/** Mark one live scheduled automation deleted while keeping its history. */
+async function deleteScheduledAutomation(db, id, nowMs = Date.now()) {
+	return await withScheduledAutomationLock(db, id, async (tx) => {
+		const current = await readScheduledAutomation(tx, id);
+		if (!current || current.status === "deleted") return void 0;
+		const deleted = requireStoredTask({
+			...current,
+			nextRunAtMs: void 0,
+			runNowAtMs: void 0,
+			status: "deleted",
+			updatedAtMs: nowMs
+		});
+		await writeScheduledAutomation(tx, deleted, current);
+		return deleted;
+	});
+}
+// src/api/conversations/aggregate.ts
+function usageTokenValue(source, field) {
+	return sql`CASE
+    WHEN ${source.usage}->>${field} IS NOT NULL
+      THEN (${source.usage}->>${field})::double precision
+    ELSE NULL
+  END`;
+}
+function tokenValue(source) {
+	return sql`
+    CASE
+      WHEN COALESCE(
+        ${source.usage}->>'inputTokens',
+        ${source.usage}->>'outputTokens',
+        ${source.usage}->>'cachedInputTokens',
+        ${source.usage}->>'cacheCreationTokens'
+      ) IS NOT NULL
+        THEN COALESCE((${source.usage}->>'inputTokens')::double precision, 0)
+          + COALESCE((${source.usage}->>'outputTokens')::double precision, 0)
+          + COALESCE((${source.usage}->>'cachedInputTokens')::double precision, 0)
+          + COALESCE((${source.usage}->>'cacheCreationTokens')::double precision, 0)
+      WHEN ${source.usage}->>'totalTokens' IS NOT NULL
+        THEN (${source.usage}->>'totalTokens')::double precision
+      ELSE NULL
+    END
+  `;
+}
+function costValue(source) {
+	return conversationUsageCostExpr(source.usage);
+}
+/** Read one conversation row's usage cost as a SQL expression. */
+function conversationUsageCostExpr(usage) {
+	return sql`
+    CASE
+      WHEN ${usage}->'cost'->>'total' IS NOT NULL
+        THEN (${usage}->'cost'->>'total')::double precision
+      WHEN COALESCE(
+        ${usage}->'cost'->>'input',
+        ${usage}->'cost'->>'output',
+        ${usage}->'cost'->>'cacheRead',
+        ${usage}->'cost'->>'cacheWrite'
+      ) IS NOT NULL
+        THEN COALESCE((${usage}->'cost'->>'input')::double precision, 0)
+          + COALESCE((${usage}->'cost'->>'output')::double precision, 0)
+          + COALESCE((${usage}->'cost'->>'cacheRead')::double precision, 0)
+          + COALESCE((${usage}->'cost'->>'cacheWrite')::double precision, 0)
+      ELSE NULL
+    END
+  `;
+}
+/** Select complete conversation metrics inside the database instead of materializing source rows. */
+function conversationAggregateColumns(sources) {
+	const metrics = sources?.metrics ?? juniorConversations;
+	const roots = sources?.roots ?? juniorConversations;
+	const conversationCount = sources ? sql`COUNT(DISTINCT ${roots.conversationId})` : sql`COUNT(*)`;
+	return {
+		active: sql`${conversationCount} FILTER (
+      WHERE ${roots.executionStatus} NOT IN ('idle', 'failed')
+    )::integer`,
+		conversations: sql`${conversationCount}::integer`,
+		cachedInputTokens: sql`SUM(${usageTokenValue(metrics, "cachedInputTokens")})::double precision`,
+		cacheCreationTokens: sql`SUM(${usageTokenValue(metrics, "cacheCreationTokens")})::double precision`,
+		costUsd: sql`SUM(${costValue(metrics)})::double precision`,
+		durationMs: sql`COALESCE(SUM(${metrics.durationMs}), 0)::double precision`,
+		failed: sql`${conversationCount} FILTER (
+      WHERE ${roots.executionStatus} = 'failed'
+    )::integer`,
+		inputTokens: sql`SUM(${usageTokenValue(metrics, "inputTokens")})::double precision`,
+		tokens: sql`SUM(${tokenValue(metrics)})::double precision`
+	};
+}
+/** Select the complete first/last activity range for a grouped conversation aggregate. */
+function conversationRangeColumns() {
+	return {
+		firstSeenAt: sql`MIN(${juniorConversations.createdAt})`.mapWith(juniorConversations.createdAt),
+		lastSeenAt: sql`MAX(${juniorConversations.lastActivityAt})`.mapWith(juniorConversations.lastActivityAt)
+	};
+}
+/** Count distinct UTC activity dates without loading conversation timestamps into the app. */
+function conversationActiveDaysColumn() {
+	return sql`COUNT(DISTINCT (${juniorConversations.lastActivityAt} AT TIME ZONE 'UTC')::date)::integer`;
+}
+// src/chat/automations/execution-stats.ts
+const AUTOMATION_EXECUTION_STATUSES = [
+	"blocked",
+	"completed",
+	"failed"
+];
+/** An execution is a run with an outcome. Skipped runs are not executions. */
+function isExecution() {
+	return and(inArray(juniorAutomationRuns.status, [...AUTOMATION_EXECUTION_STATUSES]), isNotNull(juniorAutomationRuns.completedAtMs));
+}
+function addUsd(current, next) {
+	return Math.round((current + next) * 0xe8d4a51000) / 0xe8d4a51000;
+}
+const EMPTY_RUN_WINDOWS = {
+	1: 0,
+	7: 0,
+	30: 0,
+	90: 0
+};
+/** Empty run or cost windows for automations with no execution history. */
+function emptyAutomationRunWindows() {
+	return { ...EMPTY_RUN_WINDOWS };
+}
+function utcDate(nowMs) {
+	return new Date(nowMs).toISOString().slice(0, 10);
+}
+function emptyDay(date) {
+	return {
+		costUsd: 0,
+		date,
+		event: 0,
+		scheduled: 0
+	};
+}
+function emptyStatusDay(date) {
+	return {
+		blocked: 0,
+		completed: 0,
+		date,
+		failed: 0
+	};
+}
+/**
+* Return the Conversation id when that Conversation exists, else null. A
+* dispatch can end before it creates its Conversation, and the run's
+* `conversation_id` is a foreign key.
+*/
+function existingConversationId(conversationId) {
+	return sql`(select ${juniorConversations.conversationId} from ${juniorConversations} where ${juniorConversations.conversationId} = ${conversationId})`;
+}
+/**
+* Record the outcome of one Automation run. A run that already has an outcome
+* keeps it. A failed write is logged, and the heartbeat settles a started
+* event run later.
+*/
+async function recordAutomationExecution(automationId, options) {
+	const nowMs = options.nowMs ?? Date.now();
+	const status = options.status ?? "completed";
+	const outcome = {
+		completedAtMs: nowMs,
+		errorMessage: options.errorMessage ?? null,
+		status
+	};
+	try {
+		await getDb().insert(juniorAutomationRuns).values({
+			id: options.executionId,
+			automationId,
+			conversationId: options.conversationId ? existingConversationId(options.conversationId) : null,
+			...outcome
+		}).onConflictDoUpdate({
+			target: juniorAutomationRuns.id,
+			set: {
+				...outcome,
+				conversationId: sql`coalesce(${juniorAutomationRuns.conversationId}, excluded.conversation_id)`
+			},
+			setWhere: inArray(juniorAutomationRuns.status, ["pending", "running"])
+		});
+	} catch (error) {
+		logWarn("task.execution.stat_failed", {
+			error,
+			"app.task.execution.id": options.executionId,
+			"app.task.execution.status": status,
+			"app.task.execution.task_id": automationId
+		});
+	}
+}
+/** Load usage analytics for the given automations. */
+async function readAutomationExecutionSummaries(automationIds, options = {}) {
+	if (automationIds.length === 0) return /* @__PURE__ */ new Map();
+	const nowMs = options.nowMs ?? Date.now();
+	const oneDayAgoMs = nowMs - 864e5;
+	const sevenDaysAgoMs = nowMs - 6048e5;
+	const thirtyDaysAgoMs = nowMs - 2592e6;
+	const ninetyDaysAgoMs = nowMs - 7776e6;
+	const db = getDb();
+	const selected = and(isExecution(), inArray(juniorAutomationRuns.automationId, automationIds));
+	const latest = db.selectDistinctOn([juniorAutomationRuns.automationId], {
+		status: juniorAutomationRuns.status,
+		conversationId: juniorAutomationRuns.conversationId,
+		automationId: juniorAutomationRuns.automationId
+	}).from(juniorAutomationRuns).where(selected).orderBy(juniorAutomationRuns.automationId, desc(juniorAutomationRuns.completedAtMs), desc(juniorAutomationRuns.id)).as("latest_task_execution");
+	const conversationCost = conversationUsageCostExpr(juniorConversations.usage);
+	const costSince = (sinceMs) => sql`coalesce(sum(${conversationCost}) filter (where ${juniorAutomationRuns.completedAtMs} >= ${sinceMs}), 0)::double precision`;
+	const rows = await db.select({
+		costLast1Day: costSince(oneDayAgoMs),
+		costLast7Days: costSince(sevenDaysAgoMs),
+		costLast30Days: costSince(thirtyDaysAgoMs),
+		costLast90Days: costSince(ninetyDaysAgoMs),
+		lastRunStatus: latest.status,
+		lastConversationId: latest.conversationId,
+		lastExecutedAtMs: max(juniorAutomationRuns.completedAtMs),
+		runsLast1Day: sql`count(*) filter (where ${juniorAutomationRuns.completedAtMs} >= ${oneDayAgoMs})::int`,
+		runsLast7Days: sql`count(*) filter (where ${juniorAutomationRuns.completedAtMs} >= ${sevenDaysAgoMs})::int`,
+		runsLast30Days: sql`count(*) filter (where ${juniorAutomationRuns.completedAtMs} >= ${thirtyDaysAgoMs})::int`,
+		runsLast90Days: sql`count(*) filter (where ${juniorAutomationRuns.completedAtMs} >= ${ninetyDaysAgoMs})::int`,
+		automationId: juniorAutomationRuns.automationId,
+		totalRuns: sql`count(*)::int`
+	}).from(juniorAutomationRuns).innerJoin(latest, eq(latest.automationId, juniorAutomationRuns.automationId)).leftJoin(juniorConversations, executionConversation()).where(selected).groupBy(juniorAutomationRuns.automationId, latest.conversationId, latest.status);
+	return new Map(rows.map((row) => [row.automationId, {
+		costUsd: {
+			1: addUsd(0, row.costLast1Day),
+			7: addUsd(0, row.costLast7Days),
+			30: addUsd(0, row.costLast30Days),
+			90: addUsd(0, row.costLast90Days)
+		},
+		lastRunStatus: row.lastRunStatus,
+		...row.lastConversationId ? { lastConversationId: row.lastConversationId } : void 0,
+		...row.lastExecutedAtMs !== null ? { lastExecutedAtMs: row.lastExecutedAtMs } : void 0,
+		runs: {
+			1: row.runsLast1Day,
+			7: row.runsLast7Days,
+			30: row.runsLast30Days,
+			90: row.runsLast90Days
+		},
+		totalRuns: row.totalRuns
+	}]));
+}
+/** Load a fixed trailing window of completed executions stacked by task type. */
+async function readAutomationExecutionDays(dayCount = 90, options = {}) {
+	const end = utcDate(options.nowMs ?? Date.now());
+	const endMs = Date.parse(`${end}T23:59:59.999Z`);
+	const startMs = Date.parse(`${end}T00:00:00.000Z`) - (dayCount - 1) * 864e5;
+	const executionDate = sql`to_char(to_timestamp(${juniorAutomationRuns.completedAtMs} / 1000.0) at time zone 'UTC', 'YYYY-MM-DD')`;
+	const rows = await readCompletedExecutionBuckets({
+		access: options.access,
+		bucket: executionDate,
+		endMs,
+		startMs
+	});
+	const byDate = /* @__PURE__ */ new Map();
+	for (let offset = 0; offset < dayCount; offset += 1) {
+		const date = utcDate(startMs + offset * 864e5);
+		byDate.set(date, emptyDay(date));
+	}
+	for (const row of rows) {
+		const day = byDate.get(row.date);
+		if (!day) continue;
+		if (row.kind === "scheduled") day.scheduled = row.count;
+		else if (row.kind === "event") day.event = row.count;
+		if (row.costUsd !== null && row.costUsd > 0) day.costUsd = addUsd(day.costUsd, row.costUsd);
+	}
+	return [...byDate.values()];
+}
+/** Load a fixed trailing window of completed executions stacked by hour. */
+async function readAutomationExecutionHours(hourCount = 168, options = {}) {
+	const nowMs = options.nowMs ?? Date.now();
+	const end = new Date(nowMs);
+	end.setUTCMinutes(0, 0, 0);
+	const endMs = end.getTime() + 3599999;
+	const startMs = end.getTime() - (hourCount - 1) * 36e5;
+	const executionHour = sql`to_char(to_timestamp(${juniorAutomationRuns.completedAtMs} / 1000.0) at time zone 'UTC', 'YYYY-MM-DD"T"HH24')`;
+	const rows = await readCompletedExecutionBuckets({
+		access: options.access,
+		bucket: executionHour,
+		endMs,
+		startMs
+	});
+	const byHour = /* @__PURE__ */ new Map();
+	for (let offset = 0; offset < hourCount; offset += 1) {
+		const date = new Date(startMs + offset * 36e5).toISOString().slice(0, 13);
+		byHour.set(date, emptyDay(date));
+	}
+	for (const row of rows) {
+		const hour = byHour.get(row.date);
+		if (!hour) continue;
+		if (row.kind === "scheduled") hour.scheduled = row.count;
+		else if (row.kind === "event") hour.event = row.count;
+		if (row.costUsd !== null && row.costUsd > 0) hour.costUsd = addUsd(hour.costUsd, row.costUsd);
+	}
+	return [...byHour.values()];
+}
+/** Count completed executions and their cost per time bucket and kind. */
+async function readCompletedExecutionBuckets(args) {
+	const conversationCost = conversationUsageCostExpr(juniorConversations.usage);
+	return await getDb().select({
+		count: count(),
+		costUsd: sql`SUM(${conversationCost})::double precision`,
+		date: args.bucket,
+		kind: juniorAutomations.kind
+	}).from(juniorAutomationRuns).innerJoin(juniorAutomations, eq(juniorAutomations.id, juniorAutomationRuns.automationId)).leftJoin(juniorConversations, eq(juniorConversations.conversationId, juniorAutomationRuns.conversationId)).where(and(gte(juniorAutomationRuns.completedAtMs, args.startMs), lte(juniorAutomationRuns.completedAtMs, args.endMs), eq(juniorAutomationRuns.status, "completed"), args.access)).groupBy(args.bucket, juniorAutomations.kind).orderBy(asc(args.bucket), asc(juniorAutomations.kind));
+}
+/** Load the Automation run linked to one conversation, if any. */
+async function readAutomationExecutionByConversationId(args) {
+	const [row] = await getDb().select({
+		kind: juniorAutomations.kind,
+		automationId: juniorAutomationRuns.automationId
+	}).from(juniorAutomationRuns).innerJoin(juniorAutomations, eq(juniorAutomations.id, juniorAutomationRuns.automationId)).where(eq(juniorAutomationRuns.conversationId, args.conversationId)).limit(1);
+	return row;
+}
+/**
+* Load the display name of the Automation linked to each untitled
+* conversation. Like the Automation list, the name falls back to the first
+* line of the instruction. Titled conversations and conversations without a
+* linked Automation are absent from the result.
+*/
+async function readAutomationTitlesByConversationId(conversations) {
+	const titles = /* @__PURE__ */ new Map();
+	const untitledIds = conversations.flatMap((conversation) => conversation.title ? [] : [conversation.conversationId]);
+	if (untitledIds.length === 0) return titles;
+	const rows = await getDb().select({
+		conversationId: juniorAutomationRuns.conversationId,
+		instruction: juniorAutomations.instruction,
+		title: juniorAutomations.title
+	}).from(juniorAutomationRuns).innerJoin(juniorAutomations, eq(juniorAutomations.id, juniorAutomationRuns.automationId)).where(inArray(juniorAutomationRuns.conversationId, untitledIds));
+	for (const row of rows) {
+		const title = row.title?.trim() || fallbackShortTitle(row.instruction, "");
+		if (row.conversationId && title) titles.set(row.conversationId, title);
+	}
+	return titles;
+}
+/** Load newest-first executions for one automation, with conversation titles when present. */
+async function readAutomationExecutions(args) {
+	return (await getDb().select(executionColumns).from(juniorAutomationRuns).leftJoin(juniorConversations, executionConversation()).leftJoin(juniorAutomationVersions, executionVersion()).where(and(isExecution(), eq(juniorAutomationRuns.automationId, args.automationId))).orderBy(desc(juniorAutomationRuns.completedAtMs), desc(juniorAutomationRuns.id)).limit(args.limit)).map((row) => mapAutomationExecutionRecord(row));
+}
+/** Load newest-first executions for the supplied viewer-visible automations. */
+async function readAutomationRuns(args) {
+	if (args.automationIds.length === 0) return [];
+	return (await getDb().select({
+		...executionColumns,
+		kind: juniorAutomations.kind,
+		automationId: juniorAutomationRuns.automationId
+	}).from(juniorAutomationRuns).innerJoin(juniorAutomations, eq(juniorAutomations.id, juniorAutomationRuns.automationId)).leftJoin(juniorConversations, executionConversation()).leftJoin(juniorAutomationVersions, executionVersion()).where(and(isExecution(), inArray(juniorAutomationRuns.automationId, args.automationIds))).orderBy(desc(juniorAutomationRuns.completedAtMs), desc(juniorAutomationRuns.id)).limit(args.limit)).map((row) => ({
+		...mapAutomationExecutionRecord(row),
+		kind: row.kind,
+		automationId: row.automationId
+	}));
+}
+/** Columns that describe one execution, its Conversation, and its version. */
+const executionColumns = {
+	automationVersion: juniorAutomationRuns.automationVersion,
+	conversationId: juniorAutomationRuns.conversationId,
+	credentialMode: sql`${juniorAutomationVersions.definition}->>'credentialMode'`,
+	durationMs: juniorConversations.durationMs,
+	errorMessage: juniorAutomationRuns.errorMessage,
+	executedAtMs: juniorAutomationRuns.completedAtMs,
+	executionId: juniorAutomationRuns.id,
+	scheduledForMs: juniorAutomationRuns.scheduledForMs,
+	startedAtMs: juniorAutomationRuns.startedAtMs,
+	status: juniorAutomationRuns.status,
+	title: juniorConversations.title,
+	usage: juniorConversations.usage
+};
+function executionConversation() {
+	return eq(juniorConversations.conversationId, juniorAutomationRuns.conversationId);
+}
+function executionVersion() {
+	return and(eq(juniorAutomationVersions.automationId, juniorAutomationRuns.automationId), eq(juniorAutomationVersions.version, juniorAutomationRuns.automationVersion));
+}
+function isoTime(ms) {
+	return ms === null ? void 0 : new Date(ms).toISOString();
+}
+function mapAutomationExecutionRecord(row) {
+	const title = row.title?.trim();
+	const costUsd = agentTurnCostUsd(row.usage ?? void 0);
+	const totalTokens = agentTurnTotalTokens(row.usage ?? void 0);
+	const durationMs = typeof row.durationMs === "number" && Number.isFinite(row.durationMs) && row.durationMs > 0 ? row.durationMs : void 0;
+	const error = row.errorMessage?.trim();
+	const scheduledFor = isoTime(row.scheduledForMs);
+	const startedAt = isoTime(row.startedAtMs);
+	return {
+		...row.automationVersion !== null ? { automationVersion: row.automationVersion } : void 0,
+		...row.conversationId ? { conversationId: row.conversationId } : void 0,
+		...costUsd !== void 0 ? { costUsd } : void 0,
+		...row.credentialMode === "creator" || row.credentialMode === "system" ? { credentialMode: row.credentialMode } : void 0,
+		...durationMs !== void 0 ? { durationMs } : void 0,
+		...error ? { error } : void 0,
+		executedAt: new Date(row.executedAtMs).toISOString(),
+		executionId: row.executionId,
+		...scheduledFor ? { scheduledFor } : void 0,
+		...startedAt ? { startedAt } : void 0,
+		status: row.status,
+		...title ? { title } : void 0,
+		...totalTokens !== void 0 ? { totalTokens } : void 0
+	};
+}
+/** Load a fixed trailing window of terminal executions for one automation by status. */
+async function readAutomationExecutionStatusDays(args) {
+	const dayCount = args.dayCount ?? 90;
+	const end = utcDate(args.nowMs ?? Date.now());
+	const endMs = Date.parse(`${end}T23:59:59.999Z`);
+	const startMs = Date.parse(`${end}T00:00:00.000Z`) - (dayCount - 1) * 864e5;
+	const executionDate = sql`to_char(to_timestamp(${juniorAutomationRuns.completedAtMs} / 1000.0) at time zone 'UTC', 'YYYY-MM-DD')`;
+	const rows = await readExecutionStatusBuckets({
+		automationId: args.automationId,
+		bucket: executionDate,
+		endMs,
+		startMs
+	});
+	const byDate = /* @__PURE__ */ new Map();
+	for (let offset = 0; offset < dayCount; offset += 1) {
+		const date = utcDate(startMs + offset * 864e5);
+		byDate.set(date, emptyStatusDay(date));
+	}
+	for (const row of rows) {
+		const day = byDate.get(row.date);
+		if (!day) continue;
+		if (row.status === "completed") day.completed = row.count;
+		else if (row.status === "failed") day.failed = row.count;
+		else if (row.status === "blocked") day.blocked = row.count;
+	}
+	return [...byDate.values()];
+}
+/** Load a fixed trailing window of terminal executions for one automation by hour. */
+async function readAutomationExecutionStatusHours(args) {
+	const hourCount = args.hourCount ?? 168;
+	const nowMs = args.nowMs ?? Date.now();
+	const end = new Date(nowMs);
+	end.setUTCMinutes(0, 0, 0);
+	const endMs = end.getTime() + 3599999;
+	const startMs = end.getTime() - (hourCount - 1) * 36e5;
+	const executionHour = sql`to_char(to_timestamp(${juniorAutomationRuns.completedAtMs} / 1000.0) at time zone 'UTC', 'YYYY-MM-DD"T"HH24')`;
+	const rows = await readExecutionStatusBuckets({
+		automationId: args.automationId,
+		bucket: executionHour,
+		endMs,
+		startMs
+	});
+	const byHour = /* @__PURE__ */ new Map();
+	for (let offset = 0; offset < hourCount; offset += 1) {
+		const date = new Date(startMs + offset * 36e5).toISOString().slice(0, 13);
+		byHour.set(date, emptyStatusDay(date));
+	}
+	for (const row of rows) {
+		const hour = byHour.get(row.date);
+		if (!hour) continue;
+		if (row.status === "completed") hour.completed = row.count;
+		else if (row.status === "failed") hour.failed = row.count;
+		else if (row.status === "blocked") hour.blocked = row.count;
+	}
+	return [...byHour.values()];
+}
+/** Count one automation's executions per time bucket and status. */
+async function readExecutionStatusBuckets(args) {
+	return await getDb().select({
+		count: count(),
+		date: args.bucket,
+		status: juniorAutomationRuns.status
+	}).from(juniorAutomationRuns).where(and(isExecution(), eq(juniorAutomationRuns.automationId, args.automationId), gte(juniorAutomationRuns.completedAtMs, args.startMs), lte(juniorAutomationRuns.completedAtMs, args.endMs))).groupBy(args.bucket, juniorAutomationRuns.status).orderBy(asc(args.bucket), asc(juniorAutomationRuns.status));
+}
+// src/chat/automations/blocked-notice.ts
+function buildBlockedNoticeText(automationId, title, reason) {
+	const url = getDashboardTaskLink(automationId);
+	return [
+		`Your automation *${escapeSlackMrkdwnText(title)}* is blocked. It won't run again until you resume it.`,
+		`> ${escapeSlackMrkdwnText(reason.replace(/\s+/g, " ").trim())}`,
+		url ? `Fix the problem, then ${formatSlackLink(url, "resume it")}.` : "Fix the problem, then ask me to resume it."
+	].join("\n");
+}
+/**
+* Tell an Automation's creator in a direct message that a run blocked it,
+* and why. Call this once, after the Automation itself is stored as blocked,
+* so the dashboard matches the notice. The notice is best-effort: the reason
+* also shows on the dashboard and in the Automation tools.
+*/
+async function notifyAutomationBlocked(ref) {
+	await runBestEffort(async () => {
+		const task = ref.kind === "scheduled" ? await readScheduledAutomation(getDb(), ref.automationId) : await getEventAutomation(getDb(), ref.automationId);
+		if (!task) return;
+		const title = task.title ?? fallbackShortTitle(task.task.text, ref.kind === "scheduled" ? "Scheduled automation" : "Event automation");
+		await postSlackMessage({
+			channelId: await openSlackDirectMessage(task.createdBy.slackUserId),
+			text: buildBlockedNoticeText(ref.automationId, title, ref.reason)
+		});
+	}, "automation.blocked_notice.failed", {
+		"app.task.type": ref.kind,
+		...ref.dispatchId ? { "app.dispatch.id": ref.dispatchId } : void 0
+	});
+}
+// src/chat/agent-dispatch/store.ts
+const DISPATCH_PREFIX = "junior:agent_dispatch";
+const DISPATCH_LOCK_TTL_MS = 6e5;
+const DISPATCH_MAILBOX_APPEND_INDEX_LOCK_TTL_MS = 1e4;
+const nonEmptyExactStringSchema = z.string().min(1).refine((value) => value === value.trim() && value.toLowerCase() !== "unknown");
+const pendingDispatchMailboxAppendIndexSchema = z.array(nonEmptyExactStringSchema);
+const dispatchStatusSchema = z.enum([
+	"pending",
+	"running",
+	"awaiting_resume",
+	"completed",
+	"failed",
+	"blocked"
+]);
+const dispatchActorSchema = z.object({
+	platform: z.literal("system"),
+	name: nonEmptyExactStringSchema
+}).strict();
+const dispatchRecordSchema = z.object({
+	actor: dispatchActorSchema,
+	createdAtMs: z.number().finite(),
+	credentialSubject: credentialSubjectSchema.optional(),
+	destination: destinationSchema,
+	destinationVisibility: destinationVisibilitySchema,
+	errorMessage: z.string().optional(),
+	id: nonEmptyExactStringSchema,
+	idempotencyKey: z.string().min(1),
+	input: z.string().min(1),
+	metadata: z.record(z.string(), z.string()).optional(),
+	plugin: nonEmptyExactStringSchema,
+	replyAttribution: replyAttributionSchema.optional(),
+	resultMessageTs: z.string().optional(),
+	source: sourceSchema,
+	outcomes: z.array(taskOutcomeSchema).max(5).optional(),
+	status: dispatchStatusSchema,
+	updatedAtMs: z.number().finite()
+}).strict().superRefine((record, ctx) => {
+	if (!isSlackDestination(record.destination)) {
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "Dispatch destination platform must be slack",
+			path: ["destination"]
+		});
+		return;
+	}
+	const subject = record.credentialSubject;
+	if (!subject) return;
+	if (subject.allowedWhen === "private-direct-conversation") {
+		if (!record.destination.channelId.startsWith("D")) {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				message: "Dispatch credentialSubject requires a private direct Slack destination",
+				path: ["credentialSubject"]
+			});
+			return;
+		}
+		if (subject.binding.type !== "slack-direct-conversation" || subject.binding.teamId !== record.destination.teamId || subject.binding.channelId !== record.destination.channelId) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "Dispatch credentialSubject binding must match destination",
+			path: ["credentialSubject", "binding"]
+		});
+		return;
+	}
+	if (subject.allowedWhen === "timer-watch") {
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "Dispatch credentialSubject cannot use a timer Watch binding",
+			path: ["credentialSubject", "allowedWhen"]
+		});
+		return;
+	}
+	if (subject.binding.type !== subject.allowedWhen || subject.binding.plugin !== record.plugin || subject.binding.taskId !== subject.taskId) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "Dispatch credentialSubject binding must match task",
+		path: ["credentialSubject", "binding"]
+	});
+});
+/** Return the durable key for one plugin-facing dispatch projection. */
+function getDispatchStorageKey(id) {
+	return `${DISPATCH_PREFIX}:record:${id}`;
+}
+function dispatchLockKey(id) {
+	return `${DISPATCH_PREFIX}:lock:${id}`;
+}
+function pendingDispatchMailboxAppendIndexKey() {
+	return `${DISPATCH_PREFIX}:incomplete`;
+}
+function pendingDispatchMailboxAppendIndexLockKey() {
+	return `${DISPATCH_PREFIX}:incomplete:lock`;
+}
+function normalizeMetadata(metadata) {
+	if (!metadata) return;
+	const entries = Object.entries(metadata).filter((entry) => typeof entry[0] === "string" && typeof entry[1] === "string");
+	return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+const DISPATCH_ID_PREFIX = "agent-dispatch:";
+/** Return the stable dispatch id for one plugin idempotency key. */
+function buildDispatchId(plugin, idempotencyKey) {
+	return `dispatch_${createHash("sha256").update(plugin).update("\0").update(idempotencyKey).digest("hex").slice(0, 32)}`;
+}
+/** Parse one durable dispatch projection record. */
+function parseDispatchRecord(value) {
+	const parsed = dispatchRecordSchema.safeParse(value);
+	return parsed.success ? parsed.data : void 0;
+}
+/** Return the isolated durable conversation id for one dispatch. */
+function getDispatchConversationId(dispatch) {
+	return `${DISPATCH_ID_PREFIX}${dispatch.id}`;
+}
+/** Return the stable synthetic input message id for one dispatch turn. */
+function getDispatchInputMessageId(dispatchId) {
+	return `${DISPATCH_ID_PREFIX}${dispatchId}`;
+}
+/**
+* Return the dispatch id of a dispatch Conversation, such as an Automation
+* run. Other Conversations have no dispatch.
+*/
+function getDispatchIdForConversation(conversationId) {
+	if (!conversationId.startsWith(DISPATCH_ID_PREFIX)) return void 0;
+	return conversationId.slice(15) || void 0;
+}
+/** Return the stable turn id used by every run of one dispatch. */
+function getDispatchTurnId(dispatchId) {
+	return `dispatch:${dispatchId}`;
+}
+function toDispatchProjection(record) {
+	return {
+		id: record.id,
+		status: record.status,
+		...record.resultMessageTs ? { resultMessageTs: record.resultMessageTs } : void 0,
+		...record.errorMessage ? { errorMessage: record.errorMessage } : void 0
+	};
+}
+/** Gate recovery to dispatches that can still make progress. */
+function isTerminalDispatchStatus(status) {
+	return status === "completed" || status === "failed" || status === "blocked";
+}
+/** Serialize dispatch projection mutations. */
+async function withDispatchLock(dispatchId, task) {
+	const state = getStateAdapter();
+	await state.connect();
+	const lock = await state.acquireLock(dispatchLockKey(dispatchId), DISPATCH_LOCK_TTL_MS);
+	if (!lock) throw new Error(`Could not acquire dispatch lock for ${dispatchId}`);
+	try {
+		return await task(state);
+	} finally {
+		await state.releaseLock(lock);
+	}
+}
+async function putRecord(state, record) {
+	const parsed = dispatchRecordSchema.safeParse(record);
+	if (!parsed.success) throw new Error(`Dispatch record is invalid: ${parsed.error.issues.map((issue) => `${issue.path.join(".") || "<root>"} ${issue.message}`).join("; ")}`);
+	const next = parsed.data;
+	await state.set(getDispatchStorageKey(next.id), next, JUNIOR_THREAD_STATE_TTL_MS);
+}
+async function updatePendingDispatchMailboxAppendIndex(state, update) {
+	const lock = await state.acquireLock(pendingDispatchMailboxAppendIndexLockKey(), DISPATCH_MAILBOX_APPEND_INDEX_LOCK_TTL_MS);
+	if (!lock) throw new Error("Could not acquire dispatch mailbox append index lock");
+	try {
+		const stored = await state.get(pendingDispatchMailboxAppendIndexKey());
+		const ids = stored === void 0 || stored === null ? [] : pendingDispatchMailboxAppendIndexSchema.parse(stored);
+		const next = [...new Set(update([...new Set(ids)]))].slice(-1e4);
+		if (next.length === ids.length && next.every((id, index) => id === ids[index])) return;
+		await state.set(pendingDispatchMailboxAppendIndexKey(), next, JUNIOR_THREAD_STATE_TTL_MS);
+	} finally {
+		await state.releaseLock(lock);
+	}
+}
+/** Load dispatch state for conversation work and plugin projections. */
+async function getDispatchRecord(id) {
+	const state = getStateAdapter();
+	await state.connect();
+	return parseDispatchRecord(await state.get(getDispatchStorageKey(id)));
+}
+/** Create a dispatch idempotently within its owner namespace. */
+async function createOrGetDispatch(args) {
+	const id = buildDispatchId(args.plugin, args.options.idempotencyKey);
+	return await withDispatchLock(id, async (state) => {
+		const existing = parseDispatchRecord(await state.get(getDispatchStorageKey(id)));
+		if (existing) return {
+			record: existing,
+			status: "already_exists"
+		};
+		const metadata = normalizeMetadata(args.options.metadata);
+		const record = {
+			actor: {
+				platform: "system",
+				name: args.plugin
+			},
+			createdAtMs: args.nowMs,
+			...args.options.credentialSubject ? { credentialSubject: args.options.credentialSubject } : void 0,
+			destination: args.options.destination,
+			destinationVisibility: args.options.destinationVisibility,
+			id,
+			idempotencyKey: args.options.idempotencyKey,
+			input: args.options.input,
+			...metadata ? { metadata } : void 0,
+			plugin: args.plugin,
+			...args.options.replyAttribution ? { replyAttribution: args.options.replyAttribution } : void 0,
+			...args.options.outcomes ? { outcomes: args.options.outcomes } : void 0,
+			status: "pending",
+			source: args.options.source,
+			updatedAtMs: args.nowMs
+		};
+		await updatePendingDispatchMailboxAppendIndex(state, (ids) => ids.includes(id) ? ids : [...ids, id]);
+		await putRecord(state, record);
+		return {
+			record,
+			status: "created"
+		};
+	});
+}
+async function transitionDispatch(id, transition) {
+	return await withDispatchLock(id, async (state) => {
+		const current = parseDispatchRecord(await state.get(getDispatchStorageKey(id)));
+		if (!current) return;
+		const transitioned = transition(current);
+		if (transitioned === current) return current;
+		const next = {
+			...transitioned,
+			updatedAtMs: Date.now()
+		};
+		await putRecord(state, next);
+		return next;
+	});
+}
+/** Mark a dispatch projection as actively running. */
+async function markDispatchRunning(id) {
+	return await transitionDispatch(id, (record) => isTerminalDispatchStatus(record.status) ? record : {
+		...record,
+		status: "running",
+		errorMessage: void 0
+	});
+}
+/** Project a durable awaiting-resume turn state to the plugin API. */
+async function markDispatchAwaitingResume(id) {
+	return await transitionDispatch(id, (record) => isTerminalDispatchStatus(record.status) ? record : {
+		...record,
+		status: "awaiting_resume"
+	});
+}
+async function recordEventAutomationExecution(previous, next, status) {
+	if (!next || next.status !== status || previous?.status === status) return;
+	if (next.plugin !== "junior") return;
+	const eventAutomationId = next.metadata?.eventAutomationId;
+	if (!eventAutomationId) return;
+	await recordAutomationExecution(eventAutomationId, {
+		conversationId: getDispatchConversationId(next),
+		errorMessage: next.errorMessage,
+		executionId: next.id,
+		nowMs: next.updatedAtMs,
+		status
+	});
+}
+/**
+* Project a blocked turn to the plugin API. An Event automation is blocked
+* first, so a retry after a failed write still blocks it. Its creator is told
+* when the block is first stored. The heartbeat blocks a Scheduled automation
+* and tells its creator.
+*/
+async function markDispatchBlocked(id, errorMessage, resultMessageTs) {
+	const previous = await getDispatchRecord(id);
+	const eventAutomationId = previous?.metadata?.eventAutomationId;
+	if (previous?.plugin === "junior" && eventAutomationId && !isTerminalDispatchStatus(previous.status) && await blockEventAutomation(getDb(), eventAutomationId, errorMessage)) await notifyAutomationBlocked({
+		automationId: eventAutomationId,
+		dispatchId: id,
+		kind: "event",
+		reason: errorMessage
+	});
+	const next = await transitionDispatch(id, (record) => isTerminalDispatchStatus(record.status) ? record : {
+		...record,
+		errorMessage,
+		...resultMessageTs ? { resultMessageTs } : void 0,
+		status: "blocked"
+	});
+	await recordEventAutomationExecution(previous, next, "blocked");
+	return next;
+}
+/** Project a completed turn and its accepted Slack message to the plugin API. */
+async function markDispatchCompleted(id, resultMessageTs) {
+	const previous = await getDispatchRecord(id);
+	const next = await transitionDispatch(id, (record) => isTerminalDispatchStatus(record.status) ? record : {
+		...record,
+		errorMessage: void 0,
+		...resultMessageTs ? { resultMessageTs } : void 0,
+		status: "completed"
+	});
+	await recordEventAutomationExecution(previous, next, "completed");
+	return next;
+}
+/** Project a terminal conversation turn failure to the plugin API. */
+async function markDispatchFailed(id, errorMessage, resultMessageTs) {
+	const previous = await getDispatchRecord(id);
+	const next = await transitionDispatch(id, (record) => isTerminalDispatchStatus(record.status) ? record : {
+		...record,
+		errorMessage,
+		...resultMessageTs ? { resultMessageTs } : void 0,
+		status: "failed"
+	});
+	await recordEventAutomationExecution(previous, next, "failed");
+	return next;
+}
+/** Remove a dispatch after its durable mailbox append has succeeded. */
+async function confirmDispatchMailboxAppend(id) {
+	const state = getStateAdapter();
+	await state.connect();
+	await updatePendingDispatchMailboxAppendIndex(state, (ids) => ids.filter((candidate) => candidate !== id));
+}
+/** List dispatches whose durable mailbox append may not have completed. */
+async function listPendingDispatchMailboxAppends() {
+	const state = getStateAdapter();
+	await state.connect();
+	const stored = await state.get(pendingDispatchMailboxAppendIndexKey());
+	return stored === void 0 || stored === null ? [] : [...new Set(pendingDispatchMailboxAppendIndexSchema.parse(stored))];
+}
+/** Load the dispatch under lock before its mailbox append becomes visible. */
+async function claimDispatchMailboxAppend(id) {
+	return await withDispatchLock(id, async (state) => {
+		return parseDispatchRecord(await state.get(getDispatchStorageKey(id)));
+	});
+}
+/** Return a plugin-scoped dispatch projection without exposing raw runtime state. */
+async function getPluginDispatchProjection(args) {
+	const record = await getDispatchRecord(args.id);
+	if (!record || record.plugin !== args.plugin) return;
+	return toDispatchProjection(record);
+}
+// src/chat/services/turn-session-routing.ts
+async function loadConversationChain(conversationId, conversationStore) {
+	const chain = [];
+	const seen = /* @__PURE__ */ new Set();
+	let cursor = conversationId;
+	while (cursor && !seen.has(cursor)) {
+		seen.add(cursor);
+		const conversation = await conversationStore.get({ conversationId: cursor });
+		if (!conversation) break;
+		chain.push(conversation);
+		cursor = conversation.parentConversationId;
+	}
+	return chain;
+}
+/**
+* Normalize a stored Slack session source against the conversation destination.
+*
+* Does not create channel or thread values from the conversation id.
+*/
+function slackSourceForDestination(args) {
+	if (args.source?.kind !== "slack" || args.source.channelId !== args.destination.channelId) return;
+	const threadTs = args.source.threadTs?.trim();
+	return {
+		kind: "slack",
+		visibility: args.source.visibility ?? "public",
+		teamId: args.source.teamId?.trim() || args.destination.teamId,
+		channelId: args.source.channelId,
+		...threadTs ? { threadTs } : void 0
+	};
+}
+/**
+* Resolve the Conversation Location, Destination, and session Source.
+*
+* Reads parent Conversations when this Conversation has no Destination.
+*/
+async function resolveConversationRouting(args) {
+	const conversationStore = args.conversationStore ?? (await import("./viewer-DSbD6DF6.js").then((n) => n.v)).getConversationStore();
+	const chain = await loadConversationChain(args.conversationId, conversationStore);
+	let destination;
+	let source;
+	let location;
+	for (const conversation of chain) {
+		destination ??= conversation.destination;
+		source ??= conversation.sessionSource;
+		location ??= conversation.location;
+		if (destination && source) break;
+	}
+	if (!destination) return;
+	if (destination.platform === "slack") {
+		const slackSource = slackSourceForDestination({
+			destination,
+			source
+		});
+		return {
+			destination,
+			...location ? { location } : void 0,
+			...slackSource ? { source: slackSource } : void 0
+		};
+	}
+	return {
+		destination,
+		...location ? { location } : void 0,
+		...source ? { source } : void 0
+	};
+}
+/** Require the Conversation Destination and Source from SQL. */
+async function resolveTurnSessionRouting(args) {
+	const routing = await resolveConversationRouting(args);
+	if (!routing?.destination || !routing.source) throw new Error(`Conversation ${args.conversationId} is missing durable routing metadata`);
+	return {
+		destination: routing.destination,
+		...routing.location ? { location: routing.location } : void 0,
+		source: routing.source
+	};
+}
+export { saveEventAutomation as $, recordAttemptFailure as $n, appendThreadContextMessages as $t, readAutomationRuns as A, recordTurnSummary as An, REQUEST_CONTEXT_SECTION_TAG as Ar, loadProjection as At, readScheduledAutomation as B, clearExpiredConversationLease as Bn, getAgentContextCompactionTriggerTokens as Br, recordMcpProviderConnected as Bt, readAutomationExecutionByConversationId as C, loadTurnCheckpoint as Cn, isContinuablePiBoundary as Cr, requireEventIdentifier as Ct, readAutomationExecutionStatusHours as D, failTurnRecord as Dn, retainRuntimeTurnContext as Dr, loadConnectedMcpProviders as Dt, readAutomationExecutionStatusDays as E, completeTurnRecord as En, normalizeToolNameFromResult as Er, commitMessages as Et, conversationRangeColumns as F, appendInboundMessage as Fn, SubscribedReplyReason as Fr, recordAttachmentsDelivered as Ft, blockEventAutomation as G, getConversation as Gn, createDurableLocationConfigurationService as Gr, hydrateConversationMessages as Gt, saveScheduledAutomationInLock as H, completeConversationWork as Hn, getExperimentalFeatures as Hr, recordToolExecutionStarted as Ht, createScheduledAutomation as I, beginConversationResume as In, decideSubscribedThreadReply as Ir, recordAuthenticationLinked as It, deleteEventAutomation as J, hasRunnableConversationWork as Jn, piMessageFromHistoryItem as Jr, persistConversationMessageSummaries as Jt, collectEventAutomationMatchKeys as K, getConversationWorkState as Kn, configValueSchema as Kr, persistConversationMessages as Kt, deleteScheduledAutomation as L, cancelHumanFacingPendingMessages as Ln, getSubscribedReplyPreflightDecision as Lr, recordAuthorizationCompleted as Lt, recordAutomationExecution as M, CONVERSATION_WORK_STALE_ENQUEUE_MS as Mn, TURN_CONTEXT_TAG as Mr, loadTurnRoute as Mt, conversationActiveDaysColumn as N, ackMessages as Nn, buildDeterministicAssistantMessageId as Nr, openConversationProjection as Nt, readAutomationExecutionSummaries as O, getTurnRecord as On, stripRuntimeTurnContext as Or, loadConversationProjection as Ot, conversationAggregateColumns as P, appendExclusiveInboundMessage as Pn, buildDeterministicTurnId as Pr, recordAgentsInstructionsUpdated as Pt, parseEventAutomationRow as Q, markConversationWorkEnqueued as Qn, resolveTaskTitle as Qt, listScheduledAutomationsForTeam as R, checkInConversationWork as Rn, getThreadStopDecision as Rr, recordAuthorizationRequested as Rt, existingConversationId as S, continuableMessages as Sn, isAssistantMessage as Sr, registeredResourceTypeSchema as St, readAutomationExecutionHours as T, abandonTurnRecord as Tn, isToolResultMessage as Tr, commitAcceptedReply as Tt, scheduledRunId as U, deadLetterAttempt as Un, isExperimentalFeatureEnabled as Ur, recordTurnRoute as Ut, saveScheduledAutomation as V, completeConversationStop as Vn, getAgentContextInputLimitTokens as Vr, recordSubscribedReplyRoute as Vt, withScheduledAutomationLock as W, drainConversationMailbox as Wn, setExperimentalFeatures as Wr, appendConversationMessages as Wt, getEventAutomation as X, isInvalidConversationRecordError as Xn, setConfigDefaults as Xr, settleConversationTitleWork as Xt, findMatchingEventAutomations as Y, isFinalAttempt as Yn, getConfigDefaults as Yr, resolveConversationTitle as Yt, listDeletedEventAutomationsCreatedBy as Z, listActiveConversationIds as Zn, fallbackShortTitle as Zt, markDispatchCompleted as _, abandonReplacedPendingAuth as _n, getPiMessageRole as _r, eventWatchUnavailable as _t, confirmDispatchMailboxAppend as a, markConversationMessage as an, startConversationWork as ar, listAutomationVersions as at, notifyAutomationBlocked as b, getConversationPendingAuth as bn, hasRuntimeTurnContext as br, registeredEventTriggerProblems as bt, getDispatchIdForConversation as c, turnHasReply as cn, TURN_LIMIT_DISABLED_REASON as cr, AutomationConflictError as ct, getDispatchTurnId as d, PluginCredentialFailureError as dn, TurnToolCallLimitExceededError as dr, CORE_EVENT_NAMESPACE as dt, buildConversationContext as en, recordConversationRetry as er, setEventAutomationStatus as et, getPluginDispatchProjection as f, createPluginAuthOrchestration as fn, buildTurnErrorResponse as fr, automationEventCatalog as ft, markDispatchBlocked as g, AuthorizationPauseError as gn, extractAssistantText as gr, eventNamespaceSchema as gt, markDispatchAwaitingResume as h, AuthorizationFlowDisabledError as hn, persistWithRetry as hr, eventGuidance as ht, claimDispatchMailboxAppend as i, isHumanConversationMessage as in, requestConversationWork as ir, automationVersionOf as it, readAutomationTitlesByConversationId as j, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS as jn, SESSION_CONTEXT_SECTION_TAG as jr, loadTurnProjection as jt, readAutomationExecutions as k, listTurnSummaries as kn, trimTrailingAssistantMessages as kr, loadLastModelProfile as kt, getDispatchInputMessageId as l, upsertConversationMessage as ln, TurnBudgetExceededError as lr, automationRevision as lt, listPendingDispatchMailboxAppends as m, AuthPausePersistenceError as mn, isTurnExecutionLimitExceededError as mr, eventCatalogEntry as mt, resolveTurnSessionRouting as n, estimateConversationContextTokens as nn, removeActiveConversation as nr, eventAutomationRunLimitReason as nt, createOrGetDispatch as o, normalizeConversationText as on, steerWebPendingMessages as or, readAutomationVersion as ot, isTerminalDispatchStatus as p, authorizationId as pn, createTurnLimitGate as pr, describeRegisteredEventTrigger as pt, createEventAutomation as q, hasConversationStop as qn, historyItemFromPiMessage as qr, projectConversationMessages as qt, buildDispatchId as r, getConversationMessageSlackTs as rn, requestAnotherSlice as rr, automationDefinition as rt, getDispatchConversationId as s, recordDeliveredAssistantMessage as sn, stopConversationWork as sr, sameDefinitionValue as st, resolveConversationRouting as t, createConversationMemoryService as tn, releaseConversationWork as tr, admitEventAutomationRun as tt, getDispatchRecord as u, createPluginEgress as un, TurnSliceLimitExceededError as ur, requireAutomationRevision as ut, markDispatchFailed as v, canReusePendingAuthLink as vn, getTerminalAssistantMessages as vr, hasEventCatalogEntries as vt, readAutomationExecutionDays as w, saveTurnCheckpoint as wn, isToolResultError as wr, requireValidEventTrigger as wt, emptyAutomationRunWindows as x, wasPendingAuthStopped as xn, instructionTextForProjection as xr, registeredEventTypeSchema as xt, markDispatchRunning as y, clearPendingAuth as yn, getUserMessageInstructionText as yr, registeredEventMatchSchema as yt, parseScheduledAutomationRow as z, clearConsumedConversationWake as zn, estimateTextTokens as zr, recordGuardianActionReviewed as zt };