@sentry/junior 0.272.0 → 0.273.0

package/dist/turn-session-routing-BdCTDq9m.js

@@ -0,0 +1,1625 @@
+import { D as fallbackShortTitle, Fr as formatSlackLink, Kr as postSlackMessage, Pr as escapeSlackMrkdwnText, Ur as openSlackDirectMessage, ea as JUNIOR_THREAD_STATE_TTL_MS, ia as getDashboardTaskLink, oa as ToolInputError } from "./projection-BOpi891B.js";
+import { n as botConfig } from "./config-C6FTd7PX.js";
+import { _ as runBestEffort, h as logWarn } from "./logging-CNs1e04n.js";
+import { G as agentTurnCostUsd, K as agentTurnTotalTokens, S as getDb } from "./viewer-C6Y1aXjZ.js";
+import { s as juniorConversations } from "./agent-invocations-C1RNOCs8.js";
+import { d as juniorAutomations, l as juniorAutomationRuns, u as juniorAutomationVersions } from "./executor-BafgvQcc.js";
+import { h as credentialSubjectSchema } from "./registry-B-yUrv3h.js";
+import { r as getStateAdapter } from "./adapter-umap1cth.js";
+import { O as eventAutomationSchema, S as automationVersionSchema, j as scheduledAutomationSchema } from "./automation-yffXcZt9.js";
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { and, asc, count, desc, eq, gte, inArray, isNotNull, isNull, lte, max, ne, or, sql } from "drizzle-orm";
+import { anyResourceMatchFields, describeEventTrigger, destinationSchema, destinationVisibilitySchema, eventMatchSchema, eventMatches, eventTriggerChoices, eventTriggerProblems, isSlackDestination, normalizeEventIdentifier, normalizeEventMatch, replyAttributionSchema, sourceSchema, taskOutcomeSchema } from "@sentry/junior-plugin-api";
+// src/chat/events/catalog.ts
+/** A source with nothing enabled, for a namespace that the catalog lacks. */
+const NO_SOURCE = {
+	resourceTypes: [],
+	events: {},
+	anyResourceFields: {}
+};
+/**
+* Build one catalog entry. It merges the filters of every resource type here,
+* once, so trigger checks for each event copy and each row do not merge them
+* again.
+*/
+function eventCatalogEntry(registration) {
+	return {
+		...registration,
+		anyResourceFields: anyResourceMatchFields(registration.resourceTypes)
+	};
+}
+/** Core-owned event namespace. Not a plugin publisher. */
+const CORE_EVENT_NAMESPACE = "junior";
+/** True when the catalog has any enabled registration. */
+function hasEventCatalogEntries(catalog) {
+	return Object.keys(catalog).length > 0;
+}
+/**
+* Catalog entries that durable event automations may select.
+*
+* Resource types with `automation: false` stay out of create/update schemas
+* and trigger availability. A namespace with no such resource type left is
+* removed.
+*/
+function automationEventCatalog(catalog) {
+	return Object.fromEntries(Object.entries(catalog).flatMap(([namespace, registration]) => {
+		const resourceTypes = registration.resourceTypes.filter((resourceType) => registration.limits?.[resourceType.type]?.automation !== false);
+		if (resourceTypes.length === 0) return [];
+		if (resourceTypes.length === registration.resourceTypes.length) return [[namespace, registration]];
+		const supported = new Set(resourceTypes.flatMap((resourceType) => resourceType.supportedEvents));
+		return [[namespace, eventCatalogEntry({
+			...registration,
+			resourceTypes,
+			events: Object.fromEntries(Object.entries(registration.events).filter(([eventType]) => supported.has(eventType)))
+		})]];
+	}));
+}
+/** Return why watchEvents cannot watch one resource type, if it cannot. */
+function eventWatchUnavailable(catalog, namespace, resourceType) {
+	const limits = catalog[namespace]?.limits?.[resourceType];
+	return limits?.watch === false ? limits.watchUnavailableMessage : void 0;
+}
+function enumSchema(values, unavailableMessage) {
+	if (values.length === 0) return z.string().refine(() => false, unavailableMessage);
+	return z.enum(values);
+}
+/** Build the model-facing namespace enum from enabled event plugins. */
+function eventNamespaceSchema(catalog) {
+	return enumSchema(Object.keys(catalog).sort(), "No event namespaces are enabled.");
+}
+/** Build the model-facing event enum from enabled plugin registrations. */
+function registeredEventTypeSchema(catalog) {
+	return enumSchema([...new Set(Object.values(catalog).flatMap((registration) => registration.resourceTypes.flatMap((resourceType) => resourceType.supportedEvents)))].sort(), "No event types are enabled.");
+}
+/** Build the model-facing resource type enum from enabled plugin registrations. */
+function registeredResourceTypeSchema(catalog) {
+	return enumSchema([...new Set(Object.values(catalog).flatMap((registration) => registration.resourceTypes.map((resourceType) => resourceType.type)))].sort(), "No resource types are enabled.");
+}
+/**
+* Return app guidance for one event of a namespace. The source declares it
+* once for the event, so every resource type and a trigger with no resource
+* type get the same guidance.
+*/
+function eventGuidance(catalog, namespace, eventType) {
+	return catalog[namespace]?.events[eventType]?.guidance;
+}
+/** Build the match object the tools accept for one resource type. */
+function registeredEventMatchSchema() {
+	return eventMatchSchema.optional().describe("Optional filters: exact values for the resource type matchFields. A single value must equal the event data. A list means the event value may be any one entry. For a field with list: true, the event value is a list, and it matches when it includes the value or any entry. A field with events is set only on those events, so every selected event must be in that list. Omit a key to ignore it. Unmatched events are dropped with no agent turn.");
+}
+/**
+* List why a selection cannot work with the enabled plugins. Use it for new
+* selections and for saved triggers, which can go stale after a plugin renames
+* or removes a resource type, event, or filter.
+*/
+function registeredEventTriggerProblems(catalog, selection, options) {
+	return eventTriggerProblems(catalog[selection.namespace] ?? NO_SOURCE, selection, options);
+}
+/**
+* Describe a selection with the enabled plugins, for the dashboard and Slack.
+* Its problems are the same as `registeredEventTriggerProblems`.
+*/
+function describeRegisteredEventTrigger(catalog, selection) {
+	return describeEventTrigger(catalog[selection.namespace] ?? NO_SOURCE, selection);
+}
+function uniqueMatchValues(match) {
+	if (!match || Object.keys(match).length === 0) return void 0;
+	return Object.fromEntries(Object.entries(match).map(([key, value]) => [key, Array.isArray(value) ? [...new Set(value)] : value]));
+}
+/**
+* Reject an event automation trigger or a Watch that cannot work, with every
+* problem in one message for the agent. Return its match as it is saved:
+* each text value in the case that its plugin declares, with no repeated
+* list values.
+*/
+function requireValidEventTrigger(catalog, selection, target) {
+	const fields = eventTriggerChoices(catalog[selection.namespace] ?? NO_SOURCE, selection)?.fields ?? {};
+	const normalized = {
+		...selection,
+		match: normalizeEventMatch(fields, selection.match)
+	};
+	const problems = registeredEventTriggerProblems(catalog, normalized, { inputKeys: true });
+	if (problems.length > 0) {
+		const source = catalog[selection.namespace]?.displayName ?? selection.namespace;
+		const resource = selection.resourceType ? `${source} ${selection.resourceType.replaceAll("_", " ")}` : source;
+		throw new ToolInputError([target === "watch" ? `This ${resource} watch cannot be created.` : `This ${resource} trigger cannot be saved.`, ...problems.map((problem) => problem.message)].join(" "));
+	}
+	return uniqueMatchValues(normalized.match);
+}
+/**
+* Normalize one selector with the convention declared by its plugin.
+*
+* Reject a selector that does not fit its resource type. Resource types can
+* share event types, so only the identifier shows which one a selector names.
+*/
+function requireEventIdentifier(catalog, input) {
+	const registration = catalog[input.namespace];
+	const identifier = normalizeEventIdentifier(registration, input.identifier);
+	const resourceTypes = registration?.resourceTypes ?? [];
+	const fits = (resourceType) => resourceType.identifier !== void 0 && new RegExp(resourceType.identifier.pattern).test(identifier);
+	const resourceType = resourceTypes.find((candidate) => candidate.type === input.resourceType);
+	if (!resourceType?.identifier || fits(resourceType)) return identifier;
+	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/automations/revision.ts
+/** Storage revisions prevent stale edits from replacing newer values. */
+var AutomationConflictError = class extends ToolInputError {
+	constructor() {
+		super("This Automation changed after it was loaded. Reload it before saving.");
+		this.name = "AutomationConflictError";
+	}
+};
+/** Sort object keys so equal values produce equal JSON. */
+function canonicalJson(value) {
+	if (Array.isArray(value)) return value.map(canonicalJson);
+	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, child]) => [key, canonicalJson(child)]));
+	return value;
+}
+/** Identify the stored values being edited, including lifecycle and creator authority. */
+function automationRevision(task) {
+	return createHash("sha256").update(JSON.stringify(canonicalJson(task))).digest("hex");
+}
+/** Reject a stale edit while the storage owner holds the write lock. */
+function requireAutomationRevision(task, revision) {
+	if (!task || automationRevision(task) !== revision) throw new AutomationConflictError();
+}
+// src/chat/automations/versions.ts
+/** Automation versions keep each saved definition so people can see how it changed. */
+/** Return the versioned part of an Automation. Lifecycle and run state are excluded. */
+function automationDefinition(task) {
+	const common = {
+		title: task.title?.trim() || null,
+		instruction: task.task.text,
+		credentialMode: task.credentialMode,
+		destination: task.destination,
+		outcomes: task.outcomes
+	};
+	return "schedule" in task ? {
+		...common,
+		schedule: task.schedule
+	} : {
+		...common,
+		trigger: task.trigger
+	};
+}
+/** Compare definition values after key sorting. */
+function sameDefinitionValue(left, right) {
+	return JSON.stringify(canonicalJson(left)) === JSON.stringify(canonicalJson(right));
+}
+/**
+* Save a version when the definition changed. Call this in the same
+* transaction and lock as the Automation write. Without `current`, the
+* Automation is new, so the creator saves version 1.
+*/
+async function recordAutomationVersion(db, task, current, editedBy) {
+	const definition = automationDefinition(task);
+	if (current && sameDefinitionValue(automationDefinition(current), definition)) return;
+	await db.insert(juniorAutomationVersions).values({
+		automationId: task.id,
+		version: sql`(
+      SELECT coalesce(max(${juniorAutomationVersions.version}), 0) + 1
+      FROM ${juniorAutomationVersions}
+      WHERE ${juniorAutomationVersions.automationId} = ${task.id}
+    )`,
+		createdAtMs: Date.now(),
+		editedBy: editedBy ?? (current ? null : task.createdBy),
+		definition
+	});
+}
+/**
+* Select the newest saved version with the same definition as `task`.
+*
+* An Automation run stores this version so that a reader can see the
+* instruction that ran after the definition changes. The value is null when
+* no saved version has this definition.
+*/
+function automationVersionOf(task) {
+	return sql`(
+    SELECT max(${juniorAutomationVersions.version})
+    FROM ${juniorAutomationVersions}
+    WHERE ${juniorAutomationVersions.automationId} = ${task.id}
+      AND ${juniorAutomationVersions.definition} = ${JSON.stringify(automationDefinition(task))}::jsonb
+  )`;
+}
+const versionColumns = {
+	createdAtMs: juniorAutomationVersions.createdAtMs,
+	definition: juniorAutomationVersions.definition,
+	editedBy: juniorAutomationVersions.editedBy,
+	kind: juniorAutomations.kind,
+	version: juniorAutomationVersions.version
+};
+function parseVersionRow(row) {
+	return automationVersionSchema.parse({
+		kind: row.kind,
+		version: row.version,
+		createdAt: new Date(row.createdAtMs).toISOString(),
+		editedBy: row.editedBy,
+		definition: row.definition
+	});
+}
+/** Read one saved definition. */
+async function readAutomationVersion(db, automationId, version) {
+	const [row] = await db.select(versionColumns).from(juniorAutomationVersions).innerJoin(juniorAutomations, eq(juniorAutomations.id, juniorAutomationVersions.automationId)).where(and(eq(juniorAutomationVersions.automationId, automationId), eq(juniorAutomationVersions.version, version))).limit(1);
+	return row ? parseVersionRow(row) : void 0;
+}
+/** Read saved definitions, newest first. */
+async function listAutomationVersions(db, automationId, limit) {
+	return (await db.select(versionColumns).from(juniorAutomationVersions).innerJoin(juniorAutomations, eq(juniorAutomations.id, juniorAutomationVersions.automationId)).where(eq(juniorAutomationVersions.automationId, automationId)).orderBy(desc(juniorAutomationVersions.version)).limit(limit)).map(parseVersionRow);
+}
+// src/chat/event-automations/run-limit.ts
+const RUN_LIST_PREFIX = "junior:event_automation_runs:v1";
+const RUN_LIST_BURST_ROOM = 100;
+const runEntrySchema = z.union([z.object({
+	atMs: z.number().finite(),
+	id: z.string().min(1)
+}).strict(), z.object({ reset: z.literal(true) }).strict()]);
+function runListKey(automationId) {
+	return `${RUN_LIST_PREFIX}:${automationId}`;
+}
+function runListMaxLength() {
+	return botConfig.maxEventAutomationRuns + RUN_LIST_BURST_ROOM;
+}
+async function appendRunEntry(state, automationId, entry) {
+	await state.connect();
+	await state.appendToList(runListKey(automationId), entry, {
+		maxLength: runListMaxLength(),
+		ttlMs: botConfig.eventAutomationRunWindowMs
+	});
+}
+function describeRunWindow(windowMs) {
+	for (const [unit, unitMs] of [
+		["day", 864e5],
+		["hour", 36e5],
+		["minute", 6e4],
+		["second", 1e3]
+	]) if (windowMs % unitMs === 0) {
+		const count = windowMs / unitMs;
+		return count === 1 ? unit : `${count} ${unit}s`;
+	}
+	return `${windowMs} ms`;
+}
+/** Reason stored on an Event automation that the run limit blocked. */
+function eventAutomationRunLimitReason() {
+	const window = describeRunWindow(botConfig.eventAutomationRunWindowMs);
+	return `This automation reached its limit of ${botConfig.maxEventAutomationRuns} runs per ${window}. Check that its trigger is not too broad, then resume it.`;
+}
+function hasRunKey(entries, runKey) {
+	for (let index = entries.length - 1; index >= 0; index -= 1) {
+		const entry = entries[index];
+		if ("reset" in entry) return false;
+		if (entry.id === runKey) return true;
+	}
+	return false;
+}
+/**
+* Count one run of an Event automation, or refuse when its window is full.
+*
+* `runKey` is the dispatch idempotency key, so a provider retry of the same
+* Event does not count again.
+*/
+async function admitEventAutomationRun(args) {
+	const state = args.state ?? getStateAdapter();
+	await state.connect();
+	const readEntries = async () => {
+		const values = await state.getList(runListKey(args.automationId));
+		return {
+			entries: values.flatMap((value) => {
+				const entry = runEntrySchema.safeParse(value);
+				return entry.success ? [entry.data] : [];
+			}),
+			length: values.length
+		};
+	};
+	if (!hasRunKey((await readEntries()).entries, args.runKey)) await appendRunEntry(state, args.automationId, {
+		atMs: args.nowMs,
+		id: args.runKey
+	});
+	const windowStartMs = args.nowMs - botConfig.eventAutomationRunWindowMs;
+	const { entries, length } = await readEntries();
+	let lastReset = -1;
+	entries.forEach((entry, index) => {
+		if ("reset" in entry) lastReset = index;
+	});
+	const oldest = entries[0];
+	const full = lastReset === -1 && length >= runListMaxLength() && oldest !== void 0 && "atMs" in oldest && oldest.atMs > windowStartMs;
+	const runKeys = /* @__PURE__ */ new Set();
+	for (const entry of entries.slice(lastReset + 1)) {
+		if ("reset" in entry) continue;
+		if (entry.atMs > windowStartMs) runKeys.add(entry.id);
+		if (entry.id === args.runKey) return full || runKeys.size > botConfig.maxEventAutomationRuns ? "limited" : "allowed";
+	}
+	return "limited";
+}
+/**
+* Forget the runs counted for one Event automation.
+*
+* Resume and revive call this so the automation starts with a new window.
+* Call it before the automation becomes active, so an Event cannot see the
+* old full count and block it again.
+*/
+async function clearEventAutomationRuns(automationId, state = getStateAdapter()) {
+	await appendRunEntry(state, automationId, { reset: true });
+}
+// src/chat/event-automations/store.ts
+/**
+* Validate an event automation and split it into its SQL columns. Lifecycle
+* columns are written separately.
+*/
+function eventAutomationColumns(task) {
+	const { status: _status, statusReason: _statusReason, title, ...definition } = task;
+	const { createdAtMs: _createdAtMs, creatorIdentityId, id: _id, ...record } = eventAutomationSchema.parse(definition);
+	return {
+		channelId: record.destination.channelId,
+		creatorIdentityId,
+		creatorSlackUserId: record.createdBy.slackUserId,
+		identifier: record.trigger.identifier ?? null,
+		instruction: record.task.text,
+		namespace: record.trigger.namespace,
+		record,
+		teamId: record.destination.teamId,
+		title: title?.trim() || null
+	};
+}
+function eventAutomationRowInput(row) {
+	return {
+		...row.record,
+		createdAtMs: row.createdAtMs,
+		creatorIdentityId: row.creatorIdentityId,
+		id: row.id
+	};
+}
+/** Decode an event Automation row with its SQL-backed fields. */
+function parseEventAutomationRow(row) {
+	return withRowFields(row, eventAutomationSchema.parse(eventAutomationRowInput(row)));
+}
+/**
+* Decode a row for Event matching. Log and skip a row that does not parse,
+* so one bad row cannot stop matching for its whole namespace.
+*/
+function readMatchableEventAutomationRow(row) {
+	const parsed = eventAutomationSchema.safeParse(eventAutomationRowInput(row));
+	if (parsed.success) return withRowFields(row, parsed.data);
+	logWarn("event_automation.row.invalid", {
+		"app.task.id": row.id,
+		"app.task.type": "event",
+		"error.message": parsed.error.message
+	});
+}
+function withRowFields(row, task) {
+	const title = row.title?.trim();
+	return {
+		...task,
+		status: row.status,
+		...row.statusReason ? { statusReason: row.statusReason } : void 0,
+		...title ? { title } : void 0
+	};
+}
+function eventAutomationWhere(id) {
+	return and(eq(juniorAutomations.id, id), eq(juniorAutomations.kind, "event"));
+}
+function activeEventAutomationWhere() {
+	return and(eq(juniorAutomations.kind, "event"), ne(juniorAutomations.status, "deleted"));
+}
+/** Read one event automation by id, including deleted rows when present. */
+async function getEventAutomation(db, id) {
+	const rows = await db.select().from(juniorAutomations).where(eventAutomationWhere(id)).limit(1);
+	return rows[0] ? parseEventAutomationRow(rows[0]) : void 0;
+}
+/** Create one retry-stable event automation, or revive a deleted row with the new payload. */
+async function createEventAutomation(db, task) {
+	const columns = eventAutomationColumns(task);
+	if ((await getEventAutomation(db, task.id))?.status === "deleted") await clearEventAutomationRuns(task.id);
+	return db.transaction(async (tx) => {
+		const inserted = await tx.insert(juniorAutomations).values({
+			...columns,
+			createdAtMs: task.createdAtMs,
+			id: task.id,
+			kind: "event",
+			status: "active"
+		}).onConflictDoNothing().returning();
+		if (inserted[0]) {
+			const created = parseEventAutomationRow(inserted[0]);
+			await recordAutomationVersion(tx, created, void 0);
+			return created;
+		}
+		const existing = await getEventAutomation(tx, task.id);
+		if (!existing) throw new Error(`Automation ${task.id} already exists with another kind.`);
+		if (existing.status !== "deleted") return existing;
+		const rows = await tx.update(juniorAutomations).set({
+			...columns,
+			status: "active",
+			statusReason: null
+		}).where(and(eventAutomationWhere(task.id), eq(juniorAutomations.status, "deleted"))).returning();
+		if (!rows[0]) return await getEventAutomation(tx, task.id);
+		const revived = parseEventAutomationRow(rows[0]);
+		await recordAutomationVersion(tx, revived, void 0);
+		return revived;
+	});
+}
+/**
+* Replace an existing non-deleted event automation under a row lock.
+* Pass `editedBy` when a person changes the definition so its version names them.
+*/
+async function saveEventAutomation(db, task, expectedRevision, editedBy) {
+	const columns = eventAutomationColumns(task);
+	return db.transaction(async (tx) => {
+		const rows = await tx.select().from(juniorAutomations).where(eventAutomationWhere(task.id)).for("update");
+		const current = rows[0] ? parseEventAutomationRow(rows[0]) : void 0;
+		if (expectedRevision !== void 0) requireAutomationRevision(current, expectedRevision);
+		if (!current || current.status === "deleted") return void 0;
+		const saved = parseEventAutomationRow((await tx.update(juniorAutomations).set(columns).where(eventAutomationWhere(task.id)).returning())[0]);
+		await recordAutomationVersion(tx, saved, current, editedBy);
+		return saved;
+	});
+}
+/** Mark one existing event automation deleted while retaining the row for history. */
+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 deleted event automations created by one user, newest first.
+* Used only to keep historical runs after the live automation list drops the row.
+*/
+async function listDeletedEventAutomationsCreatedBy(db, user, limit) {
+	const identityIds = user.identities.map((identity) => identity.id);
+	if (identityIds.length === 0) return [];
+	return (await db.select().from(juniorAutomations).where(and(inArray(juniorAutomations.creatorIdentityId, identityIds), eq(juniorAutomations.kind, "event"), eq(juniorAutomations.status, "deleted"))).orderBy(desc(juniorAutomations.createdAtMs), desc(juniorAutomations.id)).limit(limit)).map(parseEventAutomationRow);
+}
+/**
+* Select live rows whose identifier is one of these, and rows with no
+* identifier. A row with no identifier runs for every resource of its
+* namespace, so it gets every copy of an Event.
+*/
+function eventIdentifierWhere(identifiers) {
+	return or(isNull(juniorAutomations.identifier), ...identifiers.length > 0 ? [inArray(juniorAutomations.identifier, [...identifiers])] : []);
+}
+/** SQL for rows whose trigger selects any of these event types. */
+function eventTypesWhere(eventTypes) {
+	return or(...eventTypes.map((eventType) => sql`${juniorAutomations.record}->'trigger'->'events' @> ${JSON.stringify([eventType])}::jsonb`));
+}
+/**
+* Return why a row must not run for an Event with one of these identifiers,
+* or nothing when it may.
+*
+* The identifier column and the saved trigger must agree. A row with no
+* identifier must also have a trigger that the enabled `catalog` accepts. A
+* plugin can later require a filter or stop letting an event run for every
+* resource, and the row must not stay broad.
+*/
+function eventAutomationGateProblem(row, task, identifiers, catalog) {
+	const identifier = task.trigger.identifier;
+	if (identifier !== void 0) return identifier === row.identifier && identifiers.includes(identifier) ? void 0 : "The saved trigger has a different identifier from its row.";
+	if (row.identifier !== null) return "The saved trigger has no identifier, but its row has one.";
+	const problems = registeredEventTriggerProblems(catalog, task.trigger);
+	return problems.length > 0 ? problems.map((problem) => problem.message).join(" ") : void 0;
+}
+/**
+* Read the rows that can match an Event: live rows of one team and
+* namespace whose identifier is one of these, or that have no identifier,
+* and that select one of these event types. Skip and log a row that does
+* not parse or that the gate rejects.
+*/
+async function readGatedEventAutomations(db, input) {
+	const rows = await db.select().from(juniorAutomations).where(and(eq(juniorAutomations.kind, "event"), eq(juniorAutomations.teamId, input.teamId), eq(juniorAutomations.namespace, input.namespace), eventIdentifierWhere(input.identifiers), eventTypesWhere(input.eventTypes), eq(juniorAutomations.status, "active"))).orderBy(asc(juniorAutomations.createdAtMs), asc(juniorAutomations.id));
+	const plugins = automationEventCatalog(input.catalog);
+	return rows.flatMap((row) => {
+		const task = readMatchableEventAutomationRow(row);
+		if (!task) return [];
+		const problem = eventAutomationGateProblem(row, task, input.identifiers, plugins);
+		if (problem === void 0) return [task];
+		logWarn("event_automation.gate.rejected", {
+			"app.task.id": task.id,
+			"app.task.type": "event",
+			"app.event_automation.skip_reason": problem
+		});
+		return [];
+	});
+}
+/** The filters of a match whose keys are in this data. */
+function knownMatch(match, data) {
+	if (!match) return void 0;
+	return Object.fromEntries(Object.entries(match).filter(([key]) => data[key] !== void 0));
+}
+/**
+* Collect match keys from live event automations for these identifiers and
+* event types, and from automations with no identifier. Does not evaluate
+* match values, except for automations with no identifier: one whose
+* filters on the keys in `data` fail adds no keys. So a broad trigger for
+* one repository does not make every repository load its lazy data.
+*/
+async function collectEventAutomationMatchKeys(db, input) {
+	const eventTypes = [...new Set(input.eventTypes.map((eventType) => eventType.trim()).filter(Boolean))];
+	const identifiers = [...new Set(input.identifiers.map((value) => value.trim()).filter(Boolean))];
+	if (eventTypes.length === 0) return [];
+	const tasks = await readGatedEventAutomations(db, {
+		catalog: input.catalog,
+		eventTypes,
+		identifiers,
+		namespace: input.namespace,
+		teamId: input.teamId
+	});
+	const keys = /* @__PURE__ */ new Set();
+	for (const task of tasks) {
+		if (task.trigger.identifier === void 0 && input.data && !eventMatches(knownMatch(task.trigger.match, input.data), input.data)) continue;
+		for (const key of Object.keys(task.trigger.match ?? {})) keys.add(key);
+	}
+	return [...keys].sort();
+}
+/**
+* Find every live task matching one normalized event: tasks for its exact
+* identifier, and tasks with no identifier whose filters match. The gate
+* skips a row whose trigger and identifier column disagree, and a row with
+* no identifier whose trigger the enabled `catalog` rejects.
+*/
+async function findMatchingEventAutomations(db, event, teamId, catalog) {
+	return (await readGatedEventAutomations(db, {
+		catalog,
+		eventTypes: [event.eventType],
+		identifiers: [event.identifier],
+		namespace: event.namespace,
+		teamId
+	})).filter((task) => task.trigger.events.includes(event.eventType) && eventMatches(task.trigger.match, event.data));
+}
+/**
+* Change lifecycle under the same row lock as edits, without changing
+* credentials. A pause keeps an unresolved block reason, so resuming a paused
+* blocked automation returns it to blocked. Resume a blocked automation to
+* clear the reason. A resume also clears the run-limit count first.
+*/
+async function setEventAutomationStatus(db, id, status, revision) {
+	if (status === "active" && (await getEventAutomation(db, id))?.status !== "active") await clearEventAutomationRuns(id);
+	return db.transaction(async (tx) => {
+		const rows = await tx.select().from(juniorAutomations).where(eventAutomationWhere(id)).for("update");
+		const current = rows[0] ? parseEventAutomationRow(rows[0]) : void 0;
+		requireAutomationRevision(current, revision);
+		if (!current || current.status === "deleted") throw new Error("Automation no longer exists.");
+		const next = status === "paused" ? {
+			status,
+			statusReason: current.statusReason
+		} : current.status === "paused" && current.statusReason ? {
+			status: "blocked",
+			statusReason: current.statusReason
+		} : {
+			status,
+			statusReason: void 0
+		};
+		await tx.update(juniorAutomations).set({
+			status: next.status,
+			statusReason: next.statusReason ?? null
+		}).where(eventAutomationWhere(id));
+		const { statusReason: _statusReason, ...rest } = current;
+		return {
+			...rest,
+			status: next.status,
+			...next.statusReason ? { statusReason: next.statusReason } : void 0
+		};
+	});
+}
+/**
+* Stop an event automation after a run reports a problem that only its
+* creator can fix. An active automation becomes blocked. A paused automation
+* stays paused and keeps the reason, so resume returns it to blocked.
+* Deleted automations do not change. Returns true only when this call set
+* the automation to blocked, so the creator notice goes once and never for
+* an automation that the dashboard shows as paused.
+*/
+async function blockEventAutomation(db, id, reason) {
+	return (await db.update(juniorAutomations).set({
+		status: sql`case when ${juniorAutomations.status} = 'active' then 'blocked' else ${juniorAutomations.status} end`,
+		statusReason: reason
+	}).where(and(eventAutomationWhere(id), or(eq(juniorAutomations.status, "active"), and(eq(juniorAutomations.status, "paused"), sql`${juniorAutomations.statusReason} is distinct from ${reason}`)))).returning({ status: juniorAutomations.status }))[0]?.status === "blocked";
+}
+// src/chat/scheduled-automations/tasks.ts
+const SCHEDULER_KEY_PREFIX = "junior:scheduler";
+/** Decode a Scheduled automation row. Returns undefined for an invalid row. */
+function parseScheduledAutomationRow(row) {
+	const columns = {
+		createdAtMs: row.createdAtMs,
+		creatorIdentityId: row.creatorIdentityId,
+		id: row.id,
+		nextRunAtMs: row.nextRunAtMs,
+		runNowAtMs: row.runNowAtMs,
+		status: row.status,
+		statusReason: row.statusReason,
+		title: row.title
+	};
+	const parsed = scheduledAutomationSchema.safeParse({
+		...row.record,
+		...Object.fromEntries(Object.entries(columns).filter(([, value]) => value !== null))
+	});
+	return parsed.success ? parsed.data : void 0;
+}
+/** Keep scan paths from returning current or legacy tombstones. */
+function isListedScheduledAutomation(task) {
+	return task !== void 0 && task.status !== "deleted";
+}
+/** Build the stable run id for one task occurrence. */
+function scheduledRunId(taskId, scheduledForMs) {
+	return `${taskId}:${scheduledForMs}`;
+}
+/** Acquire the deployed advisory lock for one scheduled automation. */
+function withScheduledAutomationLock(db, taskId, callback) {
+	return db.transaction(async (tx) => {
+		await tx.execute(sql`SELECT pg_advisory_xact_lock(hashtext(${`${SCHEDULER_KEY_PREFIX}:task:${taskId}:lock`}))`);
+		return await callback(tx);
+	});
+}
+function requireStoredTask(task) {
+	const parsed = scheduledAutomationSchema.safeParse(task);
+	if (!parsed.success) throw new Error("Scheduled automation routing context is invalid.");
+	const { title, ...current } = parsed.data;
+	const normalizedTitle = title?.trim() || void 0;
+	return {
+		...current,
+		...normalizedTitle ? { title: normalizedTitle } : void 0
+	};
+}
+async function upsertScheduledAutomation(db, task) {
+	const { createdAtMs, creatorIdentityId, id, nextRunAtMs, runNowAtMs, status, statusReason, title, ...record } = task;
+	const columns = {
+		channelId: record.destination.channelId,
+		createdAtMs,
+		creatorIdentityId,
+		creatorSlackUserId: record.createdBy.slackUserId,
+		instruction: record.task.text,
+		nextRunAtMs: nextRunAtMs ?? null,
+		record,
+		runNowAtMs: runNowAtMs ?? null,
+		status,
+		statusReason: statusReason ?? null,
+		teamId: record.destination.teamId,
+		title: title?.trim() || null
+	};
+	await db.insert(juniorAutomations).values({
+		...columns,
+		id,
+		kind: "scheduled"
+	}).onConflictDoUpdate({
+		target: juniorAutomations.id,
+		set: columns
+	});
+}
+/** Read and decode one scheduled automation. */
+async function readScheduledAutomation(db, taskId) {
+	const rows = await db.select().from(juniorAutomations).where(and(eq(juniorAutomations.id, taskId), eq(juniorAutomations.kind, "scheduled"))).limit(1);
+	return rows[0] ? parseScheduledAutomationRow(rows[0]) : void 0;
+}
+async function readListedScheduledAutomations(db, teamId) {
+	return (await db.select().from(juniorAutomations).where(and(eq(juniorAutomations.kind, "scheduled"), ne(juniorAutomations.status, "deleted"), teamId === void 0 ? void 0 : eq(juniorAutomations.teamId, teamId))).orderBy(asc(juniorAutomations.createdAtMs), asc(juniorAutomations.id))).map(parseScheduledAutomationRow).filter(isListedScheduledAutomation);
+}
+/** List decoded scheduled automations for one team in stable creation order. */
+async function listScheduledAutomationsForTeam(db, teamId) {
+	return await readListedScheduledAutomations(db, teamId);
+}
+async function writeScheduledAutomation(db, task, current, editedBy) {
+	if (current?.status === "blocked" && task.status === "active" && typeof task.nextRunAtMs === "number" && Number.isFinite(task.nextRunAtMs)) await db.delete(juniorAutomationRuns).where(and(eq(juniorAutomationRuns.id, scheduledRunId(task.id, task.nextRunAtMs)), eq(juniorAutomationRuns.status, "blocked")));
+	if (task.status === "deleted" && current?.status !== "deleted") await skipPendingRunsForDeletedTask(db, task);
+	await upsertScheduledAutomation(db, task);
+	await recordAutomationVersion(db, task, current, editedBy);
+}
+async function skipPendingRunsForDeletedTask(db, task) {
+	await db.update(juniorAutomationRuns).set({
+		completedAtMs: task.updatedAtMs,
+		errorMessage: `Scheduled automation ${task.id} was deleted before the run started.`,
+		status: "skipped"
+	}).where(and(eq(juniorAutomationRuns.automationId, task.id), eq(juniorAutomationRuns.status, "pending")));
+}
+/** Create a scheduled automation once under its retry-stable task lock. */
+async function createScheduledAutomation(db, task) {
+	const next = requireStoredTask(task);
+	return await withScheduledAutomationLock(db, task.id, async (tx) => {
+		const current = await readScheduledAutomation(tx, task.id);
+		if (current) return current;
+		await writeScheduledAutomation(tx, next, void 0);
+		return next;
+	});
+}
+/**
+* Save a scheduled automation and clear its blocked occurrence on reactivation.
+* Pass `editedBy` when a person changes the definition so its version names them.
+*/
+async function saveScheduledAutomation(db, task, expectedRevision, editedBy) {
+	const next = requireStoredTask(task);
+	await withScheduledAutomationLock(db, task.id, async (tx) => {
+		const current = await readScheduledAutomation(tx, task.id);
+		if (expectedRevision !== void 0) requireAutomationRevision(current, expectedRevision);
+		await writeScheduledAutomation(tx, next, current, editedBy);
+	});
+	return next;
+}
+/** Save a scheduled automation inside a task lock already held by the caller. */
+async function saveScheduledAutomationInLock(db, task, current) {
+	await writeScheduledAutomation(db, requireStoredTask(task), current);
+}
+/** 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-C6Y1aXjZ.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 $, readAutomationRuns as A, readScheduledAutomation as B, readAutomationExecutionByConversationId as C, requireEventIdentifier as Ct, readAutomationExecutionStatusHours as D, readAutomationExecutionStatusDays as E, conversationRangeColumns as F, blockEventAutomation as G, saveScheduledAutomationInLock as H, createScheduledAutomation as I, deleteEventAutomation as J, collectEventAutomationMatchKeys as K, deleteScheduledAutomation as L, recordAutomationExecution as M, conversationActiveDaysColumn as N, readAutomationExecutionSummaries as O, conversationAggregateColumns as P, parseEventAutomationRow as Q, listScheduledAutomationsForTeam as R, existingConversationId as S, registeredResourceTypeSchema as St, readAutomationExecutionHours as T, scheduledRunId as U, saveScheduledAutomation as V, withScheduledAutomationLock as W, getEventAutomation as X, findMatchingEventAutomations as Y, listDeletedEventAutomationsCreatedBy as Z, markDispatchCompleted as _, eventWatchUnavailable as _t, confirmDispatchMailboxAppend as a, listAutomationVersions as at, notifyAutomationBlocked as b, registeredEventTriggerProblems as bt, getDispatchIdForConversation as c, AutomationConflictError as ct, getDispatchTurnId as d, CORE_EVENT_NAMESPACE as dt, setEventAutomationStatus as et, getPluginDispatchProjection as f, automationEventCatalog as ft, markDispatchBlocked as g, eventNamespaceSchema as gt, markDispatchAwaitingResume as h, eventGuidance as ht, claimDispatchMailboxAppend as i, automationVersionOf as it, readAutomationTitlesByConversationId as j, readAutomationExecutions as k, getDispatchInputMessageId as l, automationRevision as lt, listPendingDispatchMailboxAppends as m, eventCatalogEntry as mt, resolveTurnSessionRouting as n, eventAutomationRunLimitReason as nt, createOrGetDispatch as o, readAutomationVersion as ot, isTerminalDispatchStatus as p, describeRegisteredEventTrigger as pt, createEventAutomation as q, buildDispatchId as r, automationDefinition as rt, getDispatchConversationId as s, sameDefinitionValue as st, resolveConversationRouting as t, admitEventAutomationRun as tt, getDispatchRecord as u, requireAutomationRevision as ut, markDispatchFailed as v, hasEventCatalogEntries as vt, readAutomationExecutionDays as w, requireValidEventTrigger as wt, emptyAutomationRunWindows as x, registeredEventTypeSchema as xt, markDispatchRunning as y, registeredEventMatchSchema as yt, parseScheduledAutomationRow as z };