@sentry/junior 0.224.0 → 0.226.0

package/dist/{task-runner-fntmnqzx.js → task-runner-axUJS1No.js}

@@ -1,16 +1,386 @@
 import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.js";
+import { p as logWarn } from "./logging-CvjMHRvg.js";
 import { _ as parseSlackMessageTs, r as credentialSubjectSchema } from "./context-Bplcgypl.js";
-import { At as createPluginConversationEvents, Kt as getConversationStore, Q as readActorIdentity, _t as createPluginState, bt as createPluginLogger, p as coreTaskRegistrations, pt as JUNIOR_THREAD_STATE_TTL_MS, qt as getDb, u as getPlugins, vt as createPluginEmbedder, yt as createPluginModel } from "./agent-hooks-DNLBwmsh.js";
-import { X as sameActorIdentity } from "./conversation-1HUoZr2l.js";
-import { C as isToolResultError, D as stripRuntimeTurnContext, J as hydrateConversationMessages, T as normalizeToolNameFromResult, b as instructionTextForProjection, g as getPiMessageRole, s as getTurnRecord, w as isToolResultMessage } from "./checkpoint-Ceck_fLO.js";
-import { w as getStateAdapter } from "./profile-6KWhg_-U.js";
-import { u as recordAutomationExecution } from "./execution-stats-DikPOxJ1.js";
-import { r as getPersistedThreadState, s as coerceThreadConversationState } from "./thread-state-Wfr0GdKS.js";
-import { t as resolveConversationRouting } from "./turn-session-routing-CQaysLoe.js";
-import { i as pluginTaskParamsSchema, o as sendVercelPluginTask, r as pluginTaskId } from "./task-queue-SL4uLfBB.js";
+import { At as createPluginConversationEvents, Kt as getConversationStore, Q as readActorIdentity, _t as createPluginState, bt as createPluginLogger, nn as agentTurnCostUsd, p as coreTaskRegistrations, pt as JUNIOR_THREAD_STATE_TTL_MS, qt as getDb, rn as agentTurnTotalTokens, u as getPlugins, vt as createPluginEmbedder, yt as createPluginModel } from "./agent-hooks-FUetyyLe.js";
+import { E as juniorConversations, s as juniorAutomationExecutions } from "./executor-D36FWjcf.js";
+import { Z as sameActorIdentity } from "./conversation-DPbmIwjy.js";
+import { C as isToolResultError, D as stripRuntimeTurnContext, J as hydrateConversationMessages, T as normalizeToolNameFromResult, b as instructionTextForProjection, g as getPiMessageRole, s as getTurnRecord, w as isToolResultMessage } from "./checkpoint-CJe-dZFF.js";
+import { w as getStateAdapter } from "./profile-dvV7PB7u.js";
+import { r as getPersistedThreadState, s as coerceThreadConversationState } from "./thread-state-CTuWhjru.js";
+import { t as resolveConversationRouting } from "./turn-session-routing-5RejBvit.js";
+import { i as pluginTaskParamsSchema, o as sendVercelPluginTask, r as pluginTaskId } from "./task-queue-TXhAWQwj.js";
 import { z } from "zod";
 import { createHash } from "node:crypto";
+import { and, asc, count, desc, eq, gte, inArray, lte, max, or, sql } from "drizzle-orm";
 import { destinationSchema, destinationVisibilitySchema, isSlackDestination, pluginRunContextSchema, replyAttributionSchema, sourceSchema, taskOutcomeSchema } from "@sentry/junior-plugin-api";
+//#region 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`;
+}
+//#endregion
+//#region src/chat/automations/execution-stats.ts
+const AUTOMATION_EXECUTION_TYPES = ["scheduled", "event"];
+const AUTOMATION_EXECUTION_STATUSES = [
+	"blocked",
+	"completed",
+	"failed"
+];
+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 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
+	};
+}
+/** Record one terminal automation execution and its durable conversation when present. */
+async function recordAutomationExecution(type, automationId, options) {
+	const namespace = options.namespace ?? "junior";
+	const nowMs = options.nowMs ?? Date.now();
+	const status = options.status ?? "completed";
+	try {
+		await getDb().insert(juniorAutomationExecutions).values({
+			...options.conversationId ? { conversationId: options.conversationId } : void 0,
+			executedAtMs: nowMs,
+			executionId: options.executionId,
+			kind: type,
+			namespace,
+			status,
+			automationId
+		}).onConflictDoNothing({ target: [
+			juniorAutomationExecutions.kind,
+			juniorAutomationExecutions.namespace,
+			juniorAutomationExecutions.executionId
+		] });
+	} catch (error) {
+		logWarn("task.execution.stat_failed", {
+			error,
+			"app.task.execution.id": options.executionId,
+			"app.task.execution.namespace": namespace,
+			"app.task.execution.status": status,
+			"app.task.execution.task_id": automationId,
+			"app.task.execution.type": type
+		});
+	}
+}
+/** Load usage analytics for all automations of one type and namespace. */
+async function readAutomationExecutionSummaries(type, namespace, options = {}) {
+	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 latest = db.selectDistinctOn([juniorAutomationExecutions.automationId], {
+		conversationId: juniorAutomationExecutions.conversationId,
+		automationId: juniorAutomationExecutions.automationId
+	}).from(juniorAutomationExecutions).where(and(eq(juniorAutomationExecutions.kind, type), eq(juniorAutomationExecutions.namespace, namespace))).orderBy(juniorAutomationExecutions.automationId, desc(juniorAutomationExecutions.executedAtMs), desc(juniorAutomationExecutions.executionId)).as("latest_task_execution");
+	const rows = await db.select({
+		lastConversationId: latest.conversationId,
+		lastExecutedAtMs: max(juniorAutomationExecutions.executedAtMs),
+		runsLast1Day: sql`count(*) filter (where ${juniorAutomationExecutions.executedAtMs} >= ${oneDayAgoMs})::int`,
+		runsLast7Days: sql`count(*) filter (where ${juniorAutomationExecutions.executedAtMs} >= ${sevenDaysAgoMs})::int`,
+		runsLast30Days: sql`count(*) filter (where ${juniorAutomationExecutions.executedAtMs} >= ${thirtyDaysAgoMs})::int`,
+		runsLast90Days: sql`count(*) filter (where ${juniorAutomationExecutions.executedAtMs} >= ${ninetyDaysAgoMs})::int`,
+		automationId: juniorAutomationExecutions.automationId,
+		totalRuns: sql`count(*)::int`
+	}).from(juniorAutomationExecutions).innerJoin(latest, eq(latest.automationId, juniorAutomationExecutions.automationId)).where(and(eq(juniorAutomationExecutions.kind, type), eq(juniorAutomationExecutions.namespace, namespace))).groupBy(juniorAutomationExecutions.automationId, latest.conversationId);
+	return new Map(rows.map((row) => [row.automationId, {
+		...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(${juniorAutomationExecutions.executedAtMs} / 1000.0) at time zone 'UTC', 'YYYY-MM-DD')`;
+	const conversationCost = conversationUsageCostExpr(juniorConversations.usage);
+	const rows = await getDb().select({
+		count: count(),
+		costUsd: sql`SUM(${conversationCost})::double precision`,
+		date: executionDate,
+		kind: juniorAutomationExecutions.kind
+	}).from(juniorAutomationExecutions).leftJoin(juniorConversations, eq(juniorConversations.conversationId, juniorAutomationExecutions.conversationId)).where(and(gte(juniorAutomationExecutions.executedAtMs, startMs), lte(juniorAutomationExecutions.executedAtMs, endMs), eq(juniorAutomationExecutions.status, "completed"))).groupBy(executionDate, juniorAutomationExecutions.kind).orderBy(asc(executionDate), asc(juniorAutomationExecutions.kind));
+	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(${juniorAutomationExecutions.executedAtMs} / 1000.0) at time zone 'UTC', 'YYYY-MM-DD"T"HH24')`;
+	const conversationCost = conversationUsageCostExpr(juniorConversations.usage);
+	const rows = await getDb().select({
+		count: count(),
+		costUsd: sql`SUM(${conversationCost})::double precision`,
+		date: executionHour,
+		kind: juniorAutomationExecutions.kind
+	}).from(juniorAutomationExecutions).leftJoin(juniorConversations, eq(juniorConversations.conversationId, juniorAutomationExecutions.conversationId)).where(and(gte(juniorAutomationExecutions.executedAtMs, startMs), lte(juniorAutomationExecutions.executedAtMs, endMs), eq(juniorAutomationExecutions.status, "completed"))).groupBy(executionHour, juniorAutomationExecutions.kind).orderBy(asc(executionHour), asc(juniorAutomationExecutions.kind));
+	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()];
+}
+/** Load the newest terminal automation execution linked to one conversation, if any. */
+async function readAutomationExecutionByConversationId(args) {
+	const namespace = args.namespace ?? "junior";
+	const row = (await getDb().select({
+		kind: juniorAutomationExecutions.kind,
+		automationId: juniorAutomationExecutions.automationId
+	}).from(juniorAutomationExecutions).where(and(eq(juniorAutomationExecutions.conversationId, args.conversationId), eq(juniorAutomationExecutions.namespace, namespace), inArray(juniorAutomationExecutions.kind, [...AUTOMATION_EXECUTION_TYPES]))).orderBy(desc(juniorAutomationExecutions.executedAtMs), desc(juniorAutomationExecutions.executionId)).limit(1))[0];
+	if (!row) return void 0;
+	if (row.kind !== "scheduled" && row.kind !== "event") return void 0;
+	return {
+		kind: row.kind,
+		automationId: row.automationId
+	};
+}
+/** Load newest-first executions for one automation, with conversation titles when present. */
+async function readAutomationExecutions(args) {
+	const namespace = args.namespace ?? "junior";
+	return (await getDb().select({
+		conversationId: juniorAutomationExecutions.conversationId,
+		durationMs: juniorConversations.durationMs,
+		executedAtMs: juniorAutomationExecutions.executedAtMs,
+		executionId: juniorAutomationExecutions.executionId,
+		status: juniorAutomationExecutions.status,
+		title: juniorConversations.title,
+		usage: juniorConversations.usage
+	}).from(juniorAutomationExecutions).leftJoin(juniorConversations, eq(juniorConversations.conversationId, juniorAutomationExecutions.conversationId)).where(and(eq(juniorAutomationExecutions.kind, args.kind), eq(juniorAutomationExecutions.namespace, namespace), eq(juniorAutomationExecutions.automationId, args.automationId))).orderBy(desc(juniorAutomationExecutions.executedAtMs), desc(juniorAutomationExecutions.executionId)).limit(args.limit)).map((row) => mapAutomationExecutionRecord(row));
+}
+/** Load newest-first executions for the supplied viewer-visible tasks. */
+async function readAutomationRuns(args) {
+	const automations = args.automations ?? [];
+	const conversationIds = [...new Set((args.conversationIds ?? []).filter((conversationId) => conversationId.trim().length > 0))];
+	if (automations.length === 0 && conversationIds.length === 0) return [];
+	const namespace = args.namespace ?? "junior";
+	const selectors = [...automations.map((task) => and(eq(juniorAutomationExecutions.kind, task.kind), eq(juniorAutomationExecutions.automationId, task.automationId))), ...conversationIds.length > 0 ? [inArray(juniorAutomationExecutions.conversationId, conversationIds)] : []];
+	return (await getDb().select({
+		conversationId: juniorAutomationExecutions.conversationId,
+		durationMs: juniorConversations.durationMs,
+		executedAtMs: juniorAutomationExecutions.executedAtMs,
+		executionId: juniorAutomationExecutions.executionId,
+		kind: juniorAutomationExecutions.kind,
+		status: juniorAutomationExecutions.status,
+		automationId: juniorAutomationExecutions.automationId,
+		title: juniorConversations.title,
+		usage: juniorConversations.usage
+	}).from(juniorAutomationExecutions).leftJoin(juniorConversations, eq(juniorConversations.conversationId, juniorAutomationExecutions.conversationId)).where(and(eq(juniorAutomationExecutions.namespace, namespace), or(...selectors))).orderBy(desc(juniorAutomationExecutions.executedAtMs), desc(juniorAutomationExecutions.executionId)).limit(args.limit)).flatMap((row) => {
+		if (row.kind !== "scheduled" && row.kind !== "event") return [];
+		return [{
+			...mapAutomationExecutionRecord(row),
+			kind: row.kind,
+			automationId: row.automationId
+		}];
+	});
+}
+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;
+	return {
+		...row.conversationId ? { conversationId: row.conversationId } : void 0,
+		...costUsd !== void 0 ? { costUsd } : void 0,
+		...durationMs !== void 0 ? { durationMs } : void 0,
+		executedAt: new Date(row.executedAtMs).toISOString(),
+		executionId: row.executionId,
+		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 namespace = args.namespace ?? "junior";
+	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(${juniorAutomationExecutions.executedAtMs} / 1000.0) at time zone 'UTC', 'YYYY-MM-DD')`;
+	const rows = await getDb().select({
+		count: count(),
+		date: executionDate,
+		status: juniorAutomationExecutions.status
+	}).from(juniorAutomationExecutions).where(and(eq(juniorAutomationExecutions.kind, args.kind), eq(juniorAutomationExecutions.namespace, namespace), eq(juniorAutomationExecutions.automationId, args.automationId), gte(juniorAutomationExecutions.executedAtMs, startMs), lte(juniorAutomationExecutions.executedAtMs, endMs), inArray(juniorAutomationExecutions.status, [...AUTOMATION_EXECUTION_STATUSES]))).groupBy(executionDate, juniorAutomationExecutions.status).orderBy(asc(executionDate), asc(juniorAutomationExecutions.status));
+	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 namespace = args.namespace ?? "junior";
+	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(${juniorAutomationExecutions.executedAtMs} / 1000.0) at time zone 'UTC', 'YYYY-MM-DD"T"HH24')`;
+	const rows = await getDb().select({
+		count: count(),
+		date: executionHour,
+		status: juniorAutomationExecutions.status
+	}).from(juniorAutomationExecutions).where(and(eq(juniorAutomationExecutions.kind, args.kind), eq(juniorAutomationExecutions.namespace, namespace), eq(juniorAutomationExecutions.automationId, args.automationId), gte(juniorAutomationExecutions.executedAtMs, startMs), lte(juniorAutomationExecutions.executedAtMs, endMs), inArray(juniorAutomationExecutions.status, [...AUTOMATION_EXECUTION_STATUSES]))).groupBy(executionHour, juniorAutomationExecutions.status).orderBy(asc(executionHour), asc(juniorAutomationExecutions.status));
+	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()];
+}
+//#endregion
 //#region src/chat/agent-dispatch/store.ts
 const DISPATCH_PREFIX = "junior:agent_dispatch";
 const DISPATCH_LOCK_TTL_MS = 6e5;
@@ -240,9 +610,8 @@ async function recordEventAutomationExecution(previous, next, status) {
 	const eventAutomationId = next.metadata?.eventAutomationId;
 	if (!eventAutomationId) return;
 	const conversationId = getDispatchConversationId(next);
-	const conversation = await getConversationStore().get({ conversationId });
 	await recordAutomationExecution("event", eventAutomationId, {
-		...conversation ? { conversationId } : void 0,
+		...await getConversationStore().get({ conversationId }) ? { conversationId } : void 0,
 		executionId: next.id,
 		nowMs: next.updatedAtMs,
 		status
@@ -561,4 +930,4 @@ async function processPluginTask(message, options = {}) {
 	});
 }
 //#endregion
-export { markDispatchFailed as _, confirmDispatchMailboxAppend as a, getDispatchInputMessageId as c, getPluginDispatchProjection as d, isTerminalDispatchStatus as f, markDispatchCompleted as g, markDispatchBlocked as h, claimDispatchMailboxAppend as i, getDispatchRecord as l, markDispatchAwaitingResume as m, scheduleSessionCompletedPluginTasks as n, createOrGetDispatch as o, listPendingDispatchMailboxAppends as p, task_runner_exports as r, getDispatchConversationId as s, processPluginTask as t, getDispatchTurnId as u, markDispatchRunning as v };
+export { conversationAggregateColumns as A, readAutomationExecutionStatusDays as C, readAutomationRuns as D, readAutomationExecutions as E, recordAutomationExecution as O, readAutomationExecutionHours as S, readAutomationExecutionSummaries as T, markDispatchFailed as _, confirmDispatchMailboxAppend as a, readAutomationExecutionByConversationId as b, getDispatchInputMessageId as c, getPluginDispatchProjection as d, isTerminalDispatchStatus as f, markDispatchCompleted as g, markDispatchBlocked as h, claimDispatchMailboxAppend as i, conversationRangeColumns as j, conversationActiveDaysColumn as k, getDispatchRecord as l, markDispatchAwaitingResume as m, scheduleSessionCompletedPluginTasks as n, createOrGetDispatch as o, listPendingDispatchMailboxAppends as p, task_runner_exports as r, getDispatchConversationId as s, processPluginTask as t, getDispatchTurnId as u, markDispatchRunning as v, readAutomationExecutionStatusHours as w, readAutomationExecutionDays as x, emptyAutomationRunWindows as y };

package/dist/{thread-state-Wfr0GdKS.js → thread-state-CTuWhjru.js}

@@ -1,9 +1,9 @@
-import { F as isRecord, I as toOptionalNumber, L as toOptionalString } from "./logging-iY0ssa2q.js";
-import { pt as JUNIOR_THREAD_STATE_TTL_MS, qt as getDb } from "./agent-hooks-DNLBwmsh.js";
+import { I as isRecord, L as toOptionalNumber, R as toOptionalString } from "./logging-CvjMHRvg.js";
+import { pt as JUNIOR_THREAD_STATE_TTL_MS, qt as getDb } from "./agent-hooks-FUetyyLe.js";
 import { n as juniorDestinations } from "./destinations-BeBiJeEM.js";
-import { u as juniorLocationConfigurations } from "./executor-BG2Armby.js";
-import { Y as persistConversationMessages } from "./checkpoint-Ceck_fLO.js";
-import { w as getStateAdapter } from "./profile-6KWhg_-U.js";
+import { u as juniorLocationConfigurations } from "./executor-D36FWjcf.js";
+import { Y as persistConversationMessages } from "./checkpoint-CJe-dZFF.js";
+import { w as getStateAdapter } from "./profile-dvV7PB7u.js";
 import { z } from "zod";
 import { randomUUID } from "node:crypto";
 import { and, eq, sql } from "drizzle-orm";

package/dist/{turn-failure-response-DLjSEm-R.js → turn-failure-response-csVoLOzx.js}

@@ -1,13 +1,12 @@
-import { y as clearPendingAuth } from "./agent-runner-9g6TQk9y.js";
-import { _ as findProviderError, h as ProviderError, v as getProviderErrorAttributes, y as getProviderErrorUserMessage } from "./client-B27ufhzl.js";
-import { F as isRecord, t as buildTurnFailureResponse } from "./logging-iY0ssa2q.js";
+import { _ as findProviderError, h as ProviderError, v as getProviderErrorAttributes, y as getProviderErrorUserMessage } from "./client-C2WBBx7m.js";
+import { I as isRecord, t as buildTurnFailureResponse } from "./logging-CvjMHRvg.js";
 import { _ as parseSlackMessageTs } from "./context-Bplcgypl.js";
-import { Wt as getConversationEventStore } from "./agent-hooks-DNLBwmsh.js";
-import { A as messageCardKey, N as readMessageCards, j as messageCardRefSchema } from "./conversation-1HUoZr2l.js";
-import { J as hydrateConversationMessages, at as markConversationMessage } from "./checkpoint-Ceck_fLO.js";
-import { qt as buildDeterministicTurnId } from "./stats-DP9zl3Jg.js";
-import { g as markTurnCompleted, h as markTurnClosed } from "./oauth-authorization-BIijVS2N.js";
-import { o as persistThreadStateById, r as getPersistedThreadState, s as coerceThreadConversationState } from "./thread-state-Wfr0GdKS.js";
+import { Wt as getConversationEventStore } from "./agent-hooks-FUetyyLe.js";
+import { A as messageCardKey, N as readMessageCards, j as messageCardRefSchema } from "./conversation-DPbmIwjy.js";
+import { J as hydrateConversationMessages, ct as markConversationMessage } from "./checkpoint-CJe-dZFF.js";
+import { r as clearPendingAuth, s as buildDeterministicTurnId } from "./pending-auth-DLNJbD8H.js";
+import { g as markTurnCompleted, h as markTurnClosed } from "./oauth-authorization-l4O1rXsL.js";
+import { o as persistThreadStateById, r as getPersistedThreadState, s as coerceThreadConversationState } from "./thread-state-CTuWhjru.js";
 //#region src/chat/conversations/pending-cards.ts
 /** Read undelivered card snapshots across resume and history replacement. */
 async function loadPendingMessageCards(conversationId) {

package/dist/{turn-lifecycle-5_jvLqRz.js → turn-lifecycle-C1S6vELh.js}

@@ -1,4 +1,4 @@
-import { Wt as getConversationEventStore } from "./agent-hooks-DNLBwmsh.js";
+import { Wt as getConversationEventStore } from "./agent-hooks-FUetyyLe.js";
 //#region src/chat/conversations/turn-lifecycle.ts
 /** Persist correlated turn lifecycle facts with retry-safe terminal exclusion. */
 var ConversationTurnLifecycleService = class {

package/dist/{turn-session-routing-CQaysLoe.js → turn-session-routing-5RejBvit.js}

@@ -34,7 +34,7 @@ function slackSourceForDestination(args) {
 * Reads parent Conversations when this Conversation has no Destination.
 */
 async function resolveConversationRouting(args) {
-	const conversationStore = args.conversationStore ?? (await import("./agent-hooks-DNLBwmsh.js").then((n) => n.Ut)).getConversationStore();
+	const conversationStore = args.conversationStore ?? (await import("./agent-hooks-FUetyyLe.js").then((n) => n.Ut)).getConversationStore();
 	const chain = await loadConversationChain(args.conversationId, conversationStore);
 	let destination;
 	let source;

package/dist/{validation-CnZkCN7o.js → validation-q2PFxkTQ.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.js";
-import { n as pluginCatalogRuntime } from "./catalog-runtime-CVZ9TEuK.js";
+import { n as pluginCatalogRuntime } from "./catalog-runtime-BYGR3Dr4.js";
 import { isDeepStrictEqual } from "node:util";
 //#region src/chat/plugins/validation.ts
 var validation_exports = /* @__PURE__ */ __exportAll({

package/dist/{version-C6lA-h_o.js → version-ByLtIYyy.js}

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "0.224.0";
+var version = "0.226.0";
 //#endregion
 //#region src/version.ts
 /** Installed Junior package version, or `unknown` when package metadata is unavailable. */

package/dist/version.js

@@ -1,2 +1,2 @@
-import { t as JUNIOR_VERSION } from "./version-C6lA-h_o.js";
+import { t as JUNIOR_VERSION } from "./version-ByLtIYyy.js";
 export { JUNIOR_VERSION };

package/dist/web-authorization-Biy8nsS7.js

@@ -0,0 +1,162 @@
+import { Pt as ensureConversationWake, Wt as requestConversationWork } from "./agent-runner-DEF7auSj.js";
+import { Wt as getConversationEventStore } from "./agent-hooks-FUetyyLe.js";
+import { n as loadTurnCheckpoint, o as failTurnRecord, s as getTurnRecord } from "./checkpoint-CJe-dZFF.js";
+import { w as getStateAdapter } from "./profile-dvV7PB7u.js";
+import { a as getVercelConversationWorkQueue } from "./job-queue-2mFFDMHB.js";
+import { n as resolveTurnSessionRouting } from "./turn-session-routing-5RejBvit.js";
+import { z } from "zod";
+import { randomUUID } from "node:crypto";
+//#region src/chat/task-execution/authorized-turn.ts
+/**
+* OAuth callbacks save readiness, not agent history. The conversation worker
+* consumes this event under its lease before it resumes the paused Turn.
+*/
+const authorizationSchema = z.object({
+	kind: z.enum(["mcp", "plugin"]),
+	provider: z.string().min(1),
+	actorId: z.string().min(1),
+	authorizationId: z.string().min(1),
+	authSessionId: z.string().optional(),
+	scope: z.string().optional(),
+	configuration: z.record(z.string(), z.unknown()).optional(),
+	toolChannelId: z.string().optional()
+});
+function authorizationKey$1(turn) {
+	return `turn:${turn.turnId}:authorization:${turn.version}`;
+}
+/** Save authorization for this parked boundary without changing model history. */
+async function recordTurnAuthorization(args) {
+	const turn = await getTurnRecord(args.conversationId, args.turnId);
+	if (!turn || turn.state !== "paused" || turn.resumeReason !== "auth") return;
+	await getConversationEventStore().append(args.conversationId, [{
+		idempotencyKey: authorizationKey$1(turn),
+		createdAtMs: Date.now(),
+		data: {
+			type: "structured_event",
+			namespace: "junior",
+			name: "turn_authorized",
+			version: 1,
+			turnId: turn.turnId,
+			content: authorizationSchema.parse(args)
+		}
+	}], { activity: "preserve" });
+	return {
+		conversationId: args.conversationId,
+		destination: args.destination,
+		turnId: turn.turnId,
+		expectedVersion: turn.version
+	};
+}
+/** Read authorization for the exact pause; a later auth pause needs its own callback. */
+async function getTurnAuthorization(turn) {
+	const event = await getConversationEventStore().loadByIdempotencyKey(turn.conversationId, authorizationKey$1(turn));
+	if (event?.data.type !== "structured_event") return void 0;
+	return authorizationSchema.parse(event.data.content);
+}
+//#endregion
+//#region src/chat/task-execution/turn-wake.ts
+/** Build the worker input for a paused turn. */
+async function getPausedTurnRequest(args) {
+	const turn = (await loadTurnCheckpoint({
+		conversationId: args.conversationId,
+		turnId: args.turnId
+	})).record;
+	if (!turn || turn.state !== "paused" || turn.resumeReason !== "timeout" && turn.resumeReason !== "yield" && turn.resumeReason !== "retry" && !(turn.resumeReason === "auth" && await getTurnAuthorization(turn)) || turn.resumeReason === "timeout" && turn.sliceId < 2) return;
+	let routing;
+	try {
+		routing = await resolveTurnSessionRouting({
+			conversationId: args.conversationId,
+			conversationStore: args.conversationStore
+		});
+	} catch (error) {
+		await failTurnRecord({
+			conversationId: args.conversationId,
+			expectedVersion: turn.version,
+			turnId: args.turnId,
+			errorMessage: error instanceof Error ? error.message : String(error)
+		});
+		return;
+	}
+	return {
+		conversationId: args.conversationId,
+		destination: routing.destination,
+		turnId: args.turnId,
+		expectedVersion: turn.version
+	};
+}
+/** Wake the conversation worker for a paused turn. */
+async function wakePausedTurn(request, options = {}) {
+	const nowMs = options.nowMs ?? Date.now();
+	await requestConversationWork({
+		conversationId: request.conversationId,
+		destination: request.destination,
+		nowMs,
+		state: options.state
+	});
+	const queue = options.queue ?? getVercelConversationWorkQueue();
+	await ensureConversationWake({
+		conversationId: request.conversationId,
+		idempotencyKey: [
+			"agent-continue",
+			request.conversationId,
+			request.turnId,
+			request.expectedVersion,
+			nowMs
+		].join(":"),
+		nowMs,
+		queue,
+		state: options.state
+	});
+}
+/** Create paused Turn operations for one app. */
+function createPausedTurns(options = {}) {
+	return {
+		get: (args) => getPausedTurnRequest({
+			...args,
+			conversationStore: options.conversationStore
+		}),
+		wake: (request) => wakePausedTurn(request, options)
+	};
+}
+/** Record completed authorization and wake the sole execution owner. */
+async function wakeAuthorizedTurn(args, queue) {
+	const request = await recordTurnAuthorization(args);
+	if (request) await wakePausedTurn(request, { queue });
+}
+//#endregion
+//#region src/chat/conversations/web-authorization.ts
+const WEB_AUTHORIZATION_PREFIX = "junior:web_authorization:v1";
+const WEB_AUTHORIZATION_TTL_MS = 864e5;
+function authorizationKey(conversationId, actorId) {
+	return `${WEB_AUTHORIZATION_PREFIX}:${conversationId}:${actorId}`;
+}
+/** Build authorization delivery for one web turn. */
+function createWebAuthorization(args) {
+	return {
+		createState: async () => randomUUID(),
+		deliver: async (request) => {
+			await getStateAdapter().set(authorizationKey(args.conversationId, args.actorId), JSON.stringify({
+				...request,
+				...args
+			}), WEB_AUTHORIZATION_TTL_MS);
+		}
+	};
+}
+/** Read the pending authorization request for one web actor. */
+async function getWebAuthorization(args) {
+	const value = await getStateAdapter().get(authorizationKey(args.conversationId, args.actorId));
+	if (typeof value !== "string") return void 0;
+	try {
+		const parsed = JSON.parse(value);
+		if (parsed.actorId !== args.actorId || parsed.conversationId !== args.conversationId || typeof parsed.authorizationUrl !== "string" || typeof parsed.label !== "string" || typeof parsed.completionText !== "string") return;
+		return parsed;
+	} catch {
+		return;
+	}
+}
+/** Remove a web authorization request after the parked turn continues. */
+async function deleteWebAuthorization(args) {
+	await getStateAdapter().delete(authorizationKey(args.conversationId, args.actorId));
+}
+//#endregion
+export { getPausedTurnRequest as a, getTurnAuthorization as c, createPausedTurns as i, deleteWebAuthorization as n, wakeAuthorizedTurn as o, getWebAuthorization as r, wakePausedTurn as s, createWebAuthorization as t };