@sentry/junior 0.267.0 → 0.269.0

package/dist/task-runner-B-PD_JOj.js

@@ -1,1074 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-nwUcYXjP.js";
-import { Bn as instructionTextForProjection, Gn as normalizeToolNameFromResult, In as getPiMessageRole, Un as isToolResultError, Wn as isToolResultMessage, gt as fallbackShortTitle, i as readScheduledAutomation, l as blockEventAutomation, m as getEventAutomation, qn as stripRuntimeTurnContext, qt as getTurnRecord, ut as hydrateConversationMessages } from "./tasks-0ilmuCux.js";
-import { _ as runBestEffort, h as logWarn } from "./logging-DuZ1A4ab.js";
-import { p as parseSlackMessageTs } from "./actor-DZSokpwj.js";
-import { D as agentTurnTotalTokens, E as agentTurnCostUsd, f as getConversationStore, p as getDb, r as readActorIdentity } from "./viewer-DrN3oC2X.js";
-import { s as juniorConversations } from "./agent-invocations-CxKldAeB.js";
-import { a as juniorAutomationRuns, o as juniorAutomationVersions, s as juniorAutomations } from "./executor-VYrx_K4w.js";
-import { m as sameActorIdentity } from "./history-C84mlAwO.js";
-import { h as credentialSubjectSchema } from "./registry-FQutO926.js";
-import { $ as postSlackMessage, An as createPluginState, Mn as createPluginModel, Nn as createPluginLogger, U as escapeSlackMrkdwnText, Un as createPluginConversationEvents, W as formatSlackLink, Z as openSlackDirectMessage, ar as createPluginCache, dn as JUNIOR_THREAD_STATE_TTL_MS, g as coreTaskRegistrations, jn as createPluginEmbedder, mn as getDashboardTaskLink, p as getPlugins } from "./credentialed-CIGwoLU2.js";
-import { i as getStateAdapter } from "./adapter-BybMEezj.js";
-import { r as getPersistedThreadState, s as coerceThreadConversationState } from "./thread-state-DRmdJ2QN.js";
-import { t as resolveConversationRouting } from "./turn-session-routing-Dyut9l7Y.js";
-import { i as pluginTaskParamsSchema, r as pluginTaskId, s as sendVercelPluginTask } from "./task-queue-B0DLgd2P.js";
-import { z } from "zod";
-import { createHash } from "node:crypto";
-import { and, asc, count, desc, eq, gte, inArray, isNotNull, lte, max, sql } from "drizzle-orm";
-import { destinationSchema, destinationVisibilitySchema, isSlackDestination, pluginRunContextSchema, replyAttributionSchema, sourceSchema, taskOutcomeSchema } from "@sentry/junior-plugin-api";
-// 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/plugins/task-runner.ts
-/**
-* Plugin background-task orchestration.
-*
-* Core schedules tasks from completed sessions and exposes plugins only a
-* bounded run projection rather than live runtime internals or queue
-* payloads.
-*/
-var task_runner_exports = /* @__PURE__ */ __exportAll({
-	processPluginTask: () => processPluginTask,
-	scheduleSessionCompletedPluginTasks: () => scheduleSessionCompletedPluginTasks
-});
-const PLUGIN_TASK_LOCK_TTL_MS = 3e5;
-function isRecord(value) {
-	return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function textPart(value) {
-	if (isRecord(value) && value.type === "text" && typeof value.text === "string") return value.text;
-}
-function messageText(message) {
-	const content = message.content;
-	if (typeof content === "string") return sanitizeText(content);
-	if (!Array.isArray(content)) return "";
-	return sanitizeText(content.map(textPart).filter(Boolean).join("\n"));
-}
-function toolResultText(message) {
-	const record = message;
-	return sanitizeText([
-		messageText(message),
-		record.output,
-		record.result,
-		record.stdout,
-		record.stderr,
-		record.toolResult
-	].filter((value) => typeof value === "string" && value.length > 0).join("\n"));
-}
-function sanitizeText(text) {
-	return text.replace(/<data_base64>[\s\S]*?<\/data_base64>/g, "<data_base64>[omitted]</data_base64>").replace(/data:image\/[a-z0-9.+-]+;base64,[a-z0-9+/=]+/gi, "[image data omitted]").replaceAll("\0", " ").trim();
-}
-/** Build the transcript provenance for a user message from its Pi provenance. */
-function messageProvenance(provenance) {
-	return {
-		authority: provenance.authority,
-		...provenance.actor ? { actor: provenance.actor } : void 0
-	};
-}
-function runTranscriptEntry(message, provenance, runActor) {
-	const role = getPiMessageRole(message);
-	if (role === "user" || role === "assistant") {
-		const text = role === "user" ? instructionTextForProjection(messageText(message)) : messageText(message);
-		if (!text) return;
-		if (role === "assistant") return {
-			type: "message",
-			role,
-			text
-		};
-		return {
-			type: "message",
-			role,
-			text,
-			provenance: messageProvenance(provenance),
-			isRunActor: sameActorIdentity(provenance.actor, runActor)
-		};
-	}
-	if (!isToolResultMessage(message)) return;
-	const toolName = normalizeToolNameFromResult(message);
-	if (!toolName) return;
-	const text = toolResultText(message);
-	return {
-		type: "toolResult",
-		toolName,
-		isError: isToolResultError(message),
-		...text ? { text } : void 0
-	};
-}
-/**
-* Slice the current turn's Pi messages with their aligned provenance and strip
-* runtime turn context, keeping each surviving message paired with the exact
-* provenance recorded for it. Stripping can drop or rewrite messages, so the
-* pairing is applied per message rather than by post-strip index.
-*/
-function turnMessagesWithProvenance(record) {
-	const startIndex = record.turnStartMessageIndex ?? 0;
-	const messages = record.piMessages.slice(startIndex);
-	const provenance = record.piMessageProvenance.slice(startIndex);
-	const paired = [];
-	for (const [index, message] of messages.entries()) for (const stripped of stripRuntimeTurnContext([message])) paired.push({
-		message: stripped,
-		provenance: provenance[index] ?? { authority: "context" }
-	});
-	return paired;
-}
-/** Recover the Slack context author identity from a persisted thread message. */
-function slackContextAuthor(location, message) {
-	const userId = message.author?.userId?.trim();
-	if (!userId) return;
-	return {
-		platform: "slack",
-		teamId: location.teamId,
-		userId,
-		...message.author?.userName ? { userName: message.author.userName } : void 0,
-		...message.author?.fullName ? { fullName: message.author.fullName } : void 0
-	};
-}
-function slackTimestampMs(value) {
-	const timestamp = parseSlackMessageTs(value);
-	if (!timestamp) return;
-	const timestampMs = Number(timestamp) * 1e3;
-	return Number.isFinite(timestampMs) ? timestampMs : void 0;
-}
-function conversationMessageTimestampMs(message) {
-	if (message.meta?.slackTs !== void 0) return slackTimestampMs(message.meta.slackTs);
-	return Number.isFinite(message.createdAtMs) ? message.createdAtMs : void 0;
-}
-function messageExistedAtRunCompletion(message, completedAtMs) {
-	const messageTimestampMs = conversationMessageTimestampMs(message);
-	return messageTimestampMs !== void 0 && messageTimestampMs <= completedAtMs;
-}
-/**
-* Project bounded public-thread context into the run transcript.
-*
-* Prior public Slack messages from the current Conversation are durable
-* evidence a completed run may have acted on, so passive consumers can cite
-* them. They are always context authority (never instruction), and private or
-* local Conversations add nothing here.
-*/
-async function loadConversationContextTranscriptEntries(record, location, visibility, runActor) {
-	if (location?.provider !== "slack" || visibility !== "public") return [];
-	const state = await getPersistedThreadState(record.conversationId);
-	const conversation = coerceThreadConversationState(state);
-	await hydrateConversationMessages({
-		conversation,
-		conversationId: record.conversationId
-	});
-	const entries = [];
-	for (const message of conversation.messages) {
-		if (message.role !== "user") continue;
-		if (!messageExistedAtRunCompletion(message, record.updatedAtMs)) continue;
-		const text = sanitizeText(message.text);
-		if (!text) continue;
-		const author = slackContextAuthor(location, message);
-		entries.push({
-			type: "message",
-			role: "user",
-			text,
-			provenance: {
-				authority: "context",
-				...author ? { actor: author } : void 0
-			},
-			isRunActor: sameActorIdentity(author, runActor)
-		});
-	}
-	return entries;
-}
-async function withPluginTaskLock(taskId, callback) {
-	const state = getStateAdapter();
-	await state.connect();
-	const lock = await state.acquireLock(`plugin:task:${taskId}`, PLUGIN_TASK_LOCK_TTL_MS);
-	if (!lock) throw new Error(`Could not acquire plugin task lock for ${taskId}`);
-	try {
-		return await callback();
-	} finally {
-		await state.releaseLock(lock);
-	}
-}
-/** Load the bounded completed-run projection exposed to plugin tasks. */
-async function loadPluginRun(params) {
-	const record = await getTurnRecord(params.conversationId, params.sessionId);
-	if (!record) throw new Error("Completed plugin task session record is unavailable");
-	if (record.state !== "completed") throw new Error("Completed plugin task session record is not completed");
-	const conversationStore = getConversationStore();
-	const routing = await resolveConversationRouting({
-		conversationId: params.conversationId,
-		conversationStore
-	});
-	if (!routing) throw new Error(`Conversation ${params.conversationId} is missing durable routing metadata`);
-	const source = record.source ?? routing.source;
-	if (!source) throw new Error("Completed plugin task session record is missing Source");
-	const conversation = await conversationStore.get({ conversationId: params.conversationId });
-	const runActor = record.actor ?? record.actors[0] ?? (record.dispatchId ? (await getDispatchRecord(record.dispatchId))?.actor : void 0);
-	const actorUser = runActor ? (await readActorIdentity(runActor))?.user : void 0;
-	const runEntries = turnMessagesWithProvenance(record).map(({ message, provenance }) => runTranscriptEntry(message, provenance, runActor)).filter((entry) => Boolean(entry));
-	const runMessageTexts = new Set(runEntries.filter((entry) => entry.type === "message").map((entry) => entry.text));
-	const contextEntries = (await loadConversationContextTranscriptEntries(record, conversation?.location, conversation?.visibility, runActor)).filter((entry) => entry.type !== "message" || !runMessageTexts.has(entry.text));
-	return pluginRunContextSchema.parse({
-		...actorUser ? { actorUserId: actorUser.id } : void 0,
-		completedAtMs: record.updatedAtMs,
-		conversationId: record.conversationId,
-		destination: routing.destination,
-		...routing.location ? { locationId: routing.location.id } : void 0,
-		actors: record.actors,
-		...runActor ? { actor: runActor } : void 0,
-		runId: record.turnId,
-		source,
-		transcript: [...contextEntries, ...runEntries]
-	});
-}
-/** Build the plugin-facing context for one claimed task attempt. */
-function taskPluginContext(plugin, message, options = {}) {
-	const pluginName = plugin.manifest.name;
-	const sessionParams = pluginTaskParamsSchema.parse(message.params);
-	return {
-		db: getDb(),
-		embedder: createPluginEmbedder(pluginName, { signal: options.signal }),
-		events: createPluginConversationEvents({
-			conversationId: sessionParams.conversationId,
-			operationId: pluginTaskId(message),
-			plugin,
-			turnId: sessionParams.sessionId
-		}),
-		id: pluginTaskId(message),
-		log: createPluginLogger(pluginName),
-		model: createPluginModel(pluginName, plugin.model, { signal: options.signal }),
-		name: message.name,
-		plugin: { name: pluginName },
-		cache: createPluginCache(pluginName),
-		run: { async load() {
-			return await loadPluginRun(sessionParams);
-		} },
-		state: createPluginState(pluginName)
-	};
-}
-function findPluginTask(message) {
-	const plugin = [...coreTaskRegistrations(), ...getPlugins()].find((candidate) => candidate.manifest.name === message.plugin);
-	if (!plugin?.tasks || !Object.hasOwn(plugin.tasks, message.name)) return;
-	return {
-		plugin,
-		task: plugin.tasks[message.name]
-	};
-}
-/** Schedule all plugin tasks interested in a completed agent-run session. */
-async function scheduleSessionCompletedPluginTasks(params, options = {}) {
-	const coreParams = pluginTaskParamsSchema.parse(params);
-	const taskRegistrations = [...getPlugins(), ...coreTaskRegistrations()].flatMap((plugin) => Object.keys(plugin.tasks ?? {}).map((name) => ({
-		name,
-		plugin
-	})));
-	if (taskRegistrations.length === 0) return;
-	const record = await getTurnRecord(coreParams.conversationId, coreParams.sessionId);
-	if (!record || record.state !== "completed") throw new Error("Completed plugin task session record is not ready");
-	const send = options.send ?? sendVercelPluginTask;
-	const messages = taskRegistrations.map(({ name, plugin }) => ({
-		name,
-		params: coreParams,
-		plugin: plugin.manifest.name
-	}));
-	await Promise.all(messages.map(async (message) => {
-		await send(message);
-	}));
-}
-/** Execute one parsed plugin task request. */
-async function processPluginTask(message, options = {}) {
-	await withPluginTaskLock(pluginTaskId(message), async () => {
-		const resolved = findPluginTask(message);
-		if (!resolved?.task) throw new Error(`Plugin task "${message.plugin}.${message.name}" is not registered`);
-		await resolved.task.run(taskPluginContext(resolved.plugin, message, options));
-	});
-}
-export { readAutomationExecutions as A, existingConversationId as C, readAutomationExecutionStatusDays as D, readAutomationExecutionHours as E, conversationAggregateColumns as F, conversationRangeColumns as I, readAutomationTitlesByConversationId as M, recordAutomationExecution as N, readAutomationExecutionStatusHours as O, conversationActiveDaysColumn as P, emptyAutomationRunWindows as S, readAutomationExecutionDays as T, markDispatchBlocked as _, claimDispatchMailboxAppend as a, markDispatchRunning as b, getDispatchConversationId as c, getDispatchRecord as d, getDispatchTurnId as f, markDispatchAwaitingResume as g, listPendingDispatchMailboxAppends as h, buildDispatchId as i, readAutomationRuns as j, readAutomationExecutionSummaries as k, getDispatchIdForConversation as l, isTerminalDispatchStatus as m, scheduleSessionCompletedPluginTasks as n, confirmDispatchMailboxAppend as o, getPluginDispatchProjection as p, task_runner_exports as r, createOrGetDispatch as s, processPluginTask as t, getDispatchInputMessageId as u, markDispatchCompleted as v, readAutomationExecutionByConversationId as w, notifyAutomationBlocked as x, markDispatchFailed as y };