@sentry/junior 0.268.0 → 0.270.0

package/dist/{tasks-SB9z-VTU.js → turn-session-routing-B9KLBhaT.js}

@@ -1,22 +1,23 @@
-import { a as completeText, f as unwrapCurrentInstruction, p as escapeXml, s as resolveGatewayModel, y as isProviderRetryError } from "./client-C1yDYjoS.js";
-import { i as getChatConfig, n as botConfig } from "./config-DrTeF80T.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-DLSpkSSr.js";
+import { a as completeText, f as unwrapCurrentInstruction, p as escapeXml, s as resolveGatewayModel, y as isProviderRetryError } from "./client-B2MjENki.js";
+import { i as getChatConfig, n as botConfig } from "./config-Dm3pWRqY.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-C6EdT6PP.js";
 import { c as parseStoredSlackActor, l as toStoredSlackActor, m as parseSlackMessageTs } from "./actor-CP9K2Idu.js";
-import { B as parseDestination, H as sameDestination, N as addAgentTurnUsage, S as startLocationThread, _ as withConversationEventLock, d as getConversationEventStore, g as createSqlConversationEventStore, h as getSqlExecutor, j as bindProviderConversation, m as getDb, p as getConversationStore } from "./viewer-CpXTGlep.js";
-import { d as juniorDestinations } from "./agent-invocations-C1RNOCs8.js";
-import { d as juniorAutomations, l as juniorAutomationRuns, p as juniorLocationConfigurations, u as juniorAutomationVersions } from "./executor-4vhvsMZJ.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-BgecKva0.js";
-import { n as pluginCatalogRuntime } from "./catalog-runtime-BD9GSpc6.js";
-import { H as startOAuthFlow, In as createPluginLogger, bt as parseSandboxEgressAuthRequiredSignal, cr as createPluginCache, dr as agentsInstructionsUpdatedEvent, fr as authenticationLinkedEvent, p as getPlugins, pn as JUNIOR_THREAD_STATE_TTL_MS, pr as authenticationUnlinkedEvent, t as executeCredentialedEgressRequest, un as sleep$1, ur as JUNIOR_NATIVE_EVENT_NAMESPACE, wt as resolveSandboxEgressProviderForHost, yn as ToolInputError, z as formatProviderLabel } from "./credentialed-lukuD-cc.js";
-import { a as MUTATION_LOCK_TTL_MS, c as withLock, i as getStateAdapter, r as getDefaultRedisStateAdapterFor, s as fenceLock } from "./adapter-04AcD2SO.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 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-BTgAfdUg.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-BB6eJkD4.js";
+import { a as agentHistoryItemSchema, g as instructionProvenanceFor, h as instructionActors, m as contextProvenance } from "./media-U6Tuz6Mi.js";
+import { f as credentialContextForActor, h as credentialSubjectSchema } from "./registry-CndmkP2P.js";
+import { n as pluginCatalogRuntime } from "./catalog-runtime-Bdym_wKy.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-BeBaJMZ_.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-BQNTKVTF.js";
+import { L as messageCardRef } from "./conversation-AhOVzN_k.js";
+import { O as eventAutomationSchema, S as automationVersionSchema, j as scheduledAutomationSchema } from "./automation-Dwh_xcqM.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) {
@@ -1047,6 +1048,12 @@ async function persistWithRetry(persist) {
 	}
 	throw lastError;
 }
+// src/chat/codemode/result.ts
+/**
+* Name of the tool that runs a Code Mode script. Nested calls use it as
+* their dispatcher name.
+*/
+const CODEMODE_TOOL_NAME = "codemode";
 // src/chat/services/turn-limit.ts
 /** Terminal failure when one turn uses too many execution slices. */
 var TurnSliceLimitExceededError = class extends Error {
@@ -1078,11 +1085,12 @@ function isTurnExecutionLimitExceededError(error) {
 	return error instanceof Error && isDirectTurnExecutionLimitError(error.cause);
 }
 /**
-* Why tools are disabled once a turn is out of budget. Junior blocks the call
-* with the same message as a tool that `disableTools` disabled. The tool list
-* stays the same, so the provider cache stays valid.
+* The result of a tool call that Junior blocks once a turn is out of budget,
+* as a direct call or as a call in a script. It names no single tool: the
+* model can reach a tool directly or through a script, so the message closes
+* both paths. The tool list stays the same, so the provider cache stays valid.
 */
-const TURN_LIMIT_DISABLED_REASON = "This Turn used its execution budget, so all tools are disabled. Reply now with what you finished, what is left, and how to continue.";
+const TURN_LIMIT_WRAP_UP_MESSAGE = `This Turn used its execution budget, so all tools are disabled, also in ${CODEMODE_TOOL_NAME} scripts. Do not call a tool again in this Turn. Reply now with what you finished, what is left, and how to continue.`;
 /**
 * Check tool calls against the turn limits for one slice.
 *
@@ -1163,12 +1171,7 @@ 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.
-	*
-	* TODO(dcramer): Set this at every ingress after every deployed worker
-	* reads it. This schema is strict, so an older worker rejects the entry.
-	*/
+	/** 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()
@@ -2699,8 +2702,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,
@@ -2717,7 +2722,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,
@@ -2726,7 +2731,7 @@ async function upsertTurnRecordLocked(args, fence) {
 			historyVersion: commit.historyVersion,
 			previousVersion: existingRecord?.version,
 			...definedProps$1({
-				actorIdentityId: existingRecord?.actorIdentityId,
+				actorIdentityId,
 				credentialSubject: existingRecord?.credentialSubject ?? args.credentialSubject,
 				cumulativeToolCallCount: args.cumulativeToolCallCount ?? existingRecord?.cumulativeToolCallCount,
 				turnLimitWrappedUp: args.turnLimitWrappedUp ?? existingRecord?.turnLimitWrappedUp,
@@ -2894,11 +2899,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,
@@ -2911,7 +2919,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,
@@ -2919,12 +2927,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
@@ -2944,7 +2952,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 {
@@ -2954,7 +2962,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),
@@ -2992,7 +3000,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);
@@ -3001,7 +3009,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),
@@ -3856,6 +3864,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}`);
@@ -3904,6 +3913,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
 	};
@@ -4580,81 +4590,6 @@ function requireEventIdentifier(catalog, input) {
 	const fitting = resourceTypes.filter(fits).map((candidate) => candidate.type);
 	throw new ToolInputError([`Identifier "${identifier}" does not fit resourceType "${input.resourceType}" in namespace "${input.namespace}". Expected format: "${resourceType.identifier.format}".`, ...fitting.length > 0 ? [`If the identifier is correct, use one of these resourceType values: ${fitting.map((type) => `"${type}"`).join(", ")}.`] : []].join(" "));
 }
-// 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-CpXTGlep.js").then((n) => n.u)).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
-	};
-}
 // src/chat/automations/revision.ts
 /** Storage revisions prevent stale edits from replacing newer values. */
 var AutomationConflictError = class extends ToolInputError {
@@ -4971,10 +4906,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.
@@ -5250,4 +5181,892 @@ async function saveScheduledAutomation(db, task, expectedRevision, editedBy) {
 async function saveScheduledAutomationInLock(db, task, current) {
 	await writeScheduledAutomation(db, requireStoredTask(task), current);
 }
-export { loadTurnRoute as $, TURN_CONTEXT_TAG as $n, CONVERSATION_WORK_STALE_ENQUEUE_MS as $t, resolveConversationRouting as A, TurnBudgetExceededError as An, upsertConversationMessage as At, registeredEventMatchSchema as B, getUserMessageInstructionText as Bn, clearPendingAuth as Bt, automationVersionOf as C, removeActiveConversation as Cn, estimateConversationContextTokens as Ct, AutomationConflictError as D, steerWebPendingMessages as Dn, normalizeConversationText as Dt, sameDefinitionValue as E, startConversationWork as En, markConversationMessage as Et, eventCatalogEntry as F, isTurnExecutionLimitExceededError as Fn, AuthPausePersistenceError as Ft, requireValidEventTrigger as G, isToolResultError as Gn, saveTurnCheckpoint as Gt, registeredEventTypeSchema as H, instructionTextForProjection as Hn, wasPendingAuthStopped as Ht, eventGuidance as I, persistWithRetry as In, AuthorizationFlowDisabledError as It, loadConnectedMcpProviders as J, retainRuntimeTurnContext as Jn, failTurnRecord as Jt, commitAcceptedReply as K, isToolResultMessage as Kn, abandonTurnRecord as Kt, eventNamespaceSchema as L, extractAssistantText as Ln, AuthorizationPauseError as Lt, CORE_EVENT_NAMESPACE as M, TurnToolCallLimitExceededError as Mn, PluginCredentialFailureError as Mt, automationEventCatalog as N, buildTurnErrorResponse as Nn, createPluginAuthOrchestration as Nt, automationRevision as O, stopConversationWork as On, recordDeliveredAssistantMessage as Ot, describeRegisteredEventTrigger as P, createTurnLimitGate as Pn, authorizationId as Pt, loadTurnProjection as Q, SESSION_CONTEXT_SECTION_TAG as Qn, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS as Qt, eventWatchUnavailable as R, getPiMessageRole as Rn, abandonReplacedPendingAuth as Rt, automationDefinition as S, releaseConversationWork as Sn, createConversationMemoryService as St, readAutomationVersion as T, requestConversationWork as Tn, isHumanConversationMessage as Tt, registeredResourceTypeSchema as U, isAssistantMessage as Un, continuableMessages as Ut, registeredEventTriggerProblems as V, hasRuntimeTurnContext as Vn, getConversationPendingAuth as Vt, requireEventIdentifier as W, isContinuablePiBoundary as Wn, loadTurnCheckpoint as Wt, loadLastModelProfile as X, trimTrailingAssistantMessages as Xn, listTurnSummaries as Xt, loadConversationProjection as Y, stripRuntimeTurnContext as Yn, getTurnRecord as Yt, loadProjection as Z, REQUEST_CONTEXT_SECTION_TAG as Zn, recordTurnSummary as Zt, parseEventAutomationRow as _, isInvalidConversationRecordError as _n, setConfigDefaults as _r, settleConversationTitleWork as _t, saveScheduledAutomation as a, checkInConversationWork as an, getThreadStopDecision as ar, recordAuthorizationRequested as at, admitEventAutomationRun as b, recordAttemptFailure as bn, appendThreadContextMessages as bt, withScheduledAutomationLock as c, completeConversationStop as cn, getAgentContextInputLimitTokens as cr, recordSubscribedReplyRoute as ct, createEventAutomation as d, drainConversationMailbox as dn, setExperimentalFeatures as dr, appendConversationMessages as dt, ackMessages as en, buildDeterministicAssistantMessageId as er, openConversationProjection as et, deleteEventAutomation as f, getConversation as fn, createDurableLocationConfigurationService as fr, hydrateConversationMessages as ft, listEventAutomationsForTeam as g, isFinalAttempt as gn, getConfigDefaults as gr, resolveConversationTitle as gt, listDeletedEventAutomationsCreatedBy as h, hasRunnableConversationWork as hn, piMessageFromHistoryItem as hr, persistConversationMessageSummaries as ht, readScheduledAutomation as i, cancelHumanFacingPendingMessages as in, getSubscribedReplyPreflightDecision as ir, recordAuthorizationCompleted as it, resolveTurnSessionRouting as j, TurnSliceLimitExceededError as jn, createPluginEgress as jt, requireAutomationRevision as k, TURN_LIMIT_DISABLED_REASON as kn, turnHasReply as kt, blockEventAutomation as l, completeConversationWork as ln, getExperimentalFeatures as lr, recordToolExecutionStarted as lt, getEventAutomation as m, hasConversationStop as mn, historyItemFromPiMessage as mr, projectConversationMessages as mt, listScheduledAutomationsForTeam as n, appendInboundMessage as nn, SubscribedReplyReason as nr, recordAttachmentsDelivered as nt, saveScheduledAutomationInLock as o, clearConsumedConversationWake as on, estimateTextTokens as or, recordGuardianActionReviewed as ot, findMatchingEventAutomations as p, getConversationWorkState as pn, configValueSchema as pr, persistConversationMessages as pt, commitMessages as q, normalizeToolNameFromResult as qn, completeTurnRecord as qt, parseScheduledAutomationRow as r, beginConversationResume as rn, decideSubscribedThreadReply as rr, recordAuthenticationLinked as rt, scheduledRunId as s, clearExpiredConversationLease as sn, getAgentContextCompactionTriggerTokens as sr, recordMcpProviderConnected as st, createScheduledAutomation as t, appendExclusiveInboundMessage as tn, buildDeterministicTurnId as tr, recordAgentsInstructionsUpdated as tt, collectEventAutomationMatchKeys as u, deadLetterAttempt as un, isExperimentalFeatureEnabled as ur, recordTurnRoute as ut, saveEventAutomation as v, listActiveConversationIds as vn, fallbackShortTitle as vt, listAutomationVersions as w, requestAnotherSlice as wn, getConversationMessageSlackTs as wt, eventAutomationRunLimitReason as x, recordConversationRetry as xn, buildConversationContext as xt, setEventAutomationStatus as y, markConversationWorkEnqueued as yn, resolveTaskTitle as yt, hasEventCatalogEntries as z, getTerminalAssistantMessages as zn, canReusePendingAuthLink 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-BTgAfdUg.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, trimTrailingAssistantMessages as Ar, loadProjection as At, readScheduledAutomation as B, clearExpiredConversationLease as Bn, estimateTextTokens as Br, recordMcpProviderConnected as Bt, readAutomationExecutionByConversationId as C, loadTurnCheckpoint as Cn, isAssistantMessage as Cr, requireEventIdentifier as Ct, readAutomationExecutionStatusHours as D, failTurnRecord as Dn, normalizeToolNameFromResult as Dr, loadConnectedMcpProviders as Dt, readAutomationExecutionStatusDays as E, completeTurnRecord as En, isToolResultMessage as Er, commitMessages as Et, conversationRangeColumns as F, appendInboundMessage as Fn, buildDeterministicTurnId as Fr, recordAttachmentsDelivered as Ft, blockEventAutomation as G, getConversation as Gn, setExperimentalFeatures as Gr, hydrateConversationMessages as Gt, saveScheduledAutomationInLock as H, completeConversationWork as Hn, getAgentContextInputLimitTokens as Hr, recordToolExecutionStarted as Ht, createScheduledAutomation as I, beginConversationResume as In, SubscribedReplyReason as Ir, recordAuthenticationLinked as It, deleteEventAutomation as J, hasRunnableConversationWork as Jn, historyItemFromPiMessage as Jr, persistConversationMessageSummaries as Jt, collectEventAutomationMatchKeys as K, getConversationWorkState as Kn, createDurableLocationConfigurationService as Kr, persistConversationMessages as Kt, deleteScheduledAutomation as L, cancelHumanFacingPendingMessages as Ln, decideSubscribedThreadReply as Lr, recordAuthorizationCompleted as Lt, recordAutomationExecution as M, CONVERSATION_WORK_STALE_ENQUEUE_MS as Mn, SESSION_CONTEXT_SECTION_TAG as Mr, loadTurnRoute as Mt, conversationActiveDaysColumn as N, ackMessages as Nn, TURN_CONTEXT_TAG as Nr, openConversationProjection as Nt, readAutomationExecutionSummaries as O, getTurnRecord as On, retainRuntimeTurnContext as Or, loadConversationProjection as Ot, conversationAggregateColumns as P, appendExclusiveInboundMessage as Pn, buildDeterministicAssistantMessageId as Pr, recordAgentsInstructionsUpdated as Pt, parseEventAutomationRow as Q, markConversationWorkEnqueued as Qn, resolveTaskTitle as Qt, listScheduledAutomationsForTeam as R, checkInConversationWork as Rn, getSubscribedReplyPreflightDecision as Rr, recordAuthorizationRequested as Rt, existingConversationId as S, continuableMessages as Sn, instructionTextForProjection as Sr, registeredResourceTypeSchema as St, readAutomationExecutionHours as T, abandonTurnRecord as Tn, isToolResultError as Tr, commitAcceptedReply as Tt, scheduledRunId as U, deadLetterAttempt as Un, getExperimentalFeatures as Ur, recordTurnRoute as Ut, saveScheduledAutomation as V, completeConversationStop as Vn, getAgentContextCompactionTriggerTokens as Vr, recordSubscribedReplyRoute as Vt, withScheduledAutomationLock as W, drainConversationMailbox as Wn, isExperimentalFeatureEnabled as Wr, appendConversationMessages as Wt, getEventAutomation as X, isInvalidConversationRecordError as Xn, getConfigDefaults as Xr, settleConversationTitleWork as Xt, findMatchingEventAutomations as Y, isFinalAttempt as Yn, piMessageFromHistoryItem as Yr, resolveConversationTitle as Yt, listDeletedEventAutomationsCreatedBy as Z, listActiveConversationIds as Zn, setConfigDefaults as Zr, fallbackShortTitle as Zt, markDispatchCompleted as _, abandonReplacedPendingAuth as _n, extractAssistantText as _r, eventWatchUnavailable as _t, confirmDispatchMailboxAppend as a, markConversationMessage as an, startConversationWork as ar, listAutomationVersions as at, notifyAutomationBlocked as b, getConversationPendingAuth as bn, getUserMessageInstructionText as br, registeredEventTriggerProblems as bt, getDispatchIdForConversation as c, turnHasReply as cn, TURN_LIMIT_WRAP_UP_MESSAGE 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, persistWithRetry as gr, eventNamespaceSchema as gt, markDispatchAwaitingResume as h, AuthorizationFlowDisabledError as hn, CODEMODE_TOOL_NAME 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, REQUEST_CONTEXT_SECTION_TAG as jr, loadTurnProjection as jt, readAutomationExecutions as k, listTurnSummaries as kn, stripRuntimeTurnContext 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, configValueSchema 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, getPiMessageRole as vr, hasEventCatalogEntries as vt, readAutomationExecutionDays as w, saveTurnCheckpoint as wn, isContinuablePiBoundary as wr, requireValidEventTrigger as wt, emptyAutomationRunWindows as x, wasPendingAuthStopped as xn, hasRuntimeTurnContext as xr, registeredEventTypeSchema as xt, markDispatchRunning as y, clearPendingAuth as yn, getTerminalAssistantMessages as yr, registeredEventMatchSchema as yt, parseScheduledAutomationRow as z, clearConsumedConversationWake as zn, getThreadStopDecision as zr, recordGuardianActionReviewed as zt };