@sentry/junior 0.206.0 → 0.208.0

package/dist/{stats-DKRP4rsY.js → stats-Cq5w_Awk.js}

@@ -1,16 +1,16 @@
-import { F as isRecord$1, I as toOptionalNumber, L as toOptionalString } from "./logging-D37bayDc.js";
-import { a as getChatConfig } from "./config-CIE83sR2.js";
-import { _ as parseSlackMessageTs, d as parseStoredSlackActor, h as parseSlackTeamId, p as parseSlackChannelId } from "./context-B45_WqVX.js";
-import { Ft as getConversationStore, It as getDb, J as withSlackRetries, Qt as sameDestination, U as getSlackClient, Xt as parseDestination, pt as JUNIOR_THREAD_STATE_TTL_MS, u as getPlugins } from "./agent-hooks-DNjlz2A-.js";
+import { F as isRecord$1, I as toOptionalNumber, L as toOptionalString } from "./logging-sNS84Yuu.js";
+import { a as getChatConfig } from "./config-EtF2uEaW.js";
+import { _ as parseSlackMessageTs, d as parseStoredSlackActor, h as parseSlackTeamId, p as parseSlackChannelId } from "./context-Bplcgypl.js";
+import { Gt as getDb, J as withSlackRetries, U as getSlackClient, Wt as getConversationStore, an as parseDestination, pt as JUNIOR_THREAD_STATE_TTL_MS, sn as sameDestination, u as getPlugins } from "./agent-hooks-CuGjLjmR.js";
 import { n as juniorDestinations } from "./destinations-BeBiJeEM.js";
-import { S as juniorAttachments, a as juniorSchedulerRuns, c as juniorStats, l as juniorEventTasks, o as juniorSchedulerTasks, w as juniorConversations } from "./executor-BfbYPW63.js";
-import { o as ToolInputError } from "./usage-D4A48Bdl.js";
-import { C as getDefaultRedisStateAdapterFor, w as getStateAdapter } from "./profile-CSixooTi.js";
+import { S as juniorAttachments, a as juniorSchedulerRuns, c as juniorStats, l as juniorEventAutomations, o as juniorSchedulerTasks, w as juniorConversations } from "./executor-BW5qp0jC.js";
+import { o as ToolInputError } from "./usage-BMuAlKIW.js";
+import { C as getDefaultRedisStateAdapterFor, w as getStateAdapter } from "./profile-BfLMVhWo.js";
 import "./vercel-queue-DIkVcfK4.js";
 import { z } from "zod";
 import { createHash, randomUUID } from "node:crypto";
 import { and, asc, desc, eq, gte, inArray, isNotNull, isNull, lte, ne, notInArray, or, sql } from "drizzle-orm";
-import { actorUserIdSchema, destinationSchema, destinationVisibilitySchema, normalizeResourceEventIdentifier, resourceEventMatchSchema, resourceEventMatches, resourceEventTypeSchema, slackDestinationSchema, taskOutcomeSchema } from "@sentry/junior-plugin-api";
+import { actorUserIdSchema, destinationSchema, destinationVisibilitySchema, eventMatchSchema, eventMatches, eventTypeSchema, normalizeEventIdentifier, slackDestinationSchema, taskOutcomeSchema } from "@sentry/junior-plugin-api";
 //#region src/chat/state/turn-id.ts
 /** Build a stable turn identifier from a message ID. */
 function buildDeterministicTurnId(messageId) {
@@ -109,7 +109,7 @@ const inboundMessageSourceSchema = z.enum([
 	"internal",
 	"local",
 	"plugin",
-	"resource_event",
+	"event",
 	"scheduler",
 	"slack",
 	"web"
@@ -583,7 +583,7 @@ async function writeConversation(state, lock, conversation) {
 		...next,
 		execution: {
 			...next.execution,
-			pendingMessages: next.execution.pendingMessages.map((message) => storeMessage(message, hasSlackDestination && (message.source === "slack" || message.source === "resource_event" || message.source === "plugin" || message.source === "scheduler")))
+			pendingMessages: next.execution.pendingMessages.map((message) => storeMessage(message, hasSlackDestination && (message.source === "slack" || message.source === "event" || message.source === "plugin" || message.source === "scheduler")))
 		}
 	};
 	await state.set(conversationKey(next.conversationId), stored, JUNIOR_THREAD_STATE_TTL_MS);
@@ -1445,43 +1445,43 @@ async function listActiveConversationIds(args = {}) {
 	return await listActiveConversationIds$1(args);
 }
 //#endregion
-//#region src/chat/resource-events/catalog.ts
-/** Core-owned resource-event namespace. Not a plugin publisher. */
-const CORE_RESOURCE_EVENT_NAMESPACE = "junior";
+//#region src/chat/events/catalog.ts
+/** Core-owned event namespace. Not a plugin publisher. */
+const CORE_EVENT_NAMESPACE = "junior";
 /** True when the catalog has any enabled registration. */
-function hasResourceEventCatalogEntries(catalog) {
+function hasEventCatalogEntries(catalog) {
 	return Object.keys(catalog).length > 0;
 }
 /**
 * True when at least one plugin namespace is enabled.
 *
 * Core Workspace snapshot events stay in the catalog for search and temporary
-* watches. Durable event tasks still require a plugin publisher.
+* watches. Durable event automations still require a plugin publisher.
 */
-function hasPluginResourceEventCatalogEntries(catalog) {
-	return Object.keys(pluginResourceEventCatalog(catalog)).length > 0;
+function hasPluginEventCatalogEntries(catalog) {
+	return Object.keys(pluginEventCatalog(catalog)).length > 0;
 }
 /**
-* Catalog entries that durable event tasks may select.
+* Catalog entries that durable event automations may select.
 *
 * Core Workspace snapshot events only wake temporary watches. Snapshot finish
-* does not run event-task ingest, so those namespaces stay out of create/update
+* does not run event-automation ingest, so those namespaces stay out of create/update
 * schemas and trigger availability.
 */
-function pluginResourceEventCatalog(catalog) {
-	return Object.fromEntries(Object.entries(catalog).filter(([namespace]) => namespace !== CORE_RESOURCE_EVENT_NAMESPACE));
+function pluginEventCatalog(catalog) {
+	return Object.fromEntries(Object.entries(catalog).filter(([namespace]) => namespace !== CORE_EVENT_NAMESPACE));
 }
 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 resource event plugins. */
+/** Build the model-facing namespace enum from enabled event plugins. */
 function eventNamespaceSchema(catalog) {
-	return enumSchema(Object.keys(catalog).sort(), "No resource event namespaces are enabled.");
+	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 resource event types are enabled.");
+	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) {
@@ -1492,22 +1492,22 @@ function pluginSupportsEvent(catalog, namespace, resourceType, eventType) {
 	return catalog[namespace]?.resourceTypes.find((candidate) => candidate.type === resourceType)?.supportedEvents.includes(eventType) ?? false;
 }
 /** Return app guidance for one registered resource type and event type. */
-function resourceEventGuidance(catalog, namespace, resourceType, eventType) {
+function eventGuidance(catalog, namespace, resourceType, eventType) {
 	return catalog[namespace]?.resourceTypes.find((candidate) => candidate.type === resourceType)?.guidance?.[eventType];
 }
 /** Return declared match keys for one registered resource type. */
-function resourceEventMatchFields(catalog, namespace, resourceType) {
+function eventMatchFields(catalog, namespace, resourceType) {
 	return catalog[namespace]?.resourceTypes.find((candidate) => candidate.type === resourceType)?.matchFields;
 }
 /** Build the match object the tools accept for one resource type. */
-function registeredResourceEventMatchSchema() {
-	return resourceEventMatchSchema.optional().describe("Optional exact values from the resource type matchFields. A single value must equal the event data. A list means the event value may be any one entry. Omit a key to ignore it. Unmatched events are dropped with no agent turn.");
+function registeredEventMatchSchema() {
+	return eventMatchSchema.optional().describe("Optional exact values from the resource type matchFields. A single value must equal the event data. A list means the event value may be any one entry. Omit a key to ignore it. Unmatched events are dropped with no agent turn.");
 }
 /** Reject match keys the resource type does not list. */
-function requireSupportedResourceEventMatch(catalog, input) {
+function requireSupportedEventMatch(catalog, input) {
 	const match = input.match;
 	if (!match || Object.keys(match).length === 0) return void 0;
-	const fields = resourceEventMatchFields(catalog, input.namespace, input.resourceType);
+	const fields = eventMatchFields(catalog, input.namespace, input.resourceType);
 	if (!fields || Object.keys(fields).length === 0) throw new ToolInputError(`Resource type "${input.namespace}:${input.resourceType}" does not support match.`);
 	const normalized = {};
 	for (const [key, value] of Object.entries(match)) {
@@ -1529,12 +1529,12 @@ function requireSupportedResourceEventMatch(catalog, input) {
 	return Object.keys(normalized).length > 0 ? normalized : void 0;
 }
 /** Normalize one selector with the convention declared by its plugin. */
-function normalizeEventIdentifier(catalog, namespace, identifier) {
-	return normalizeResourceEventIdentifier(catalog[namespace], identifier);
+function normalizeCatalogEventIdentifier(catalog, namespace, identifier) {
+	return normalizeEventIdentifier(catalog[namespace], identifier);
 }
 //#endregion
 //#region src/chat/sandbox/snapshot/events.ts
-const WORKSPACE_SNAPSHOT_NAMESPACE = CORE_RESOURCE_EVENT_NAMESPACE;
+const WORKSPACE_SNAPSHOT_NAMESPACE = CORE_EVENT_NAMESPACE;
 const WORKSPACE_SNAPSHOT_RESOURCE_TYPE = "workspace_snapshot";
 const WORKSPACE_SNAPSHOT_READY_EVENT = "workspace_snapshot.ready";
 const WORKSPACE_SNAPSHOT_FAILED_EVENT = "workspace_snapshot.failed";
@@ -1544,7 +1544,7 @@ const WORKSPACE_SNAPSHOT_FAILED_EVENT = "workspace_snapshot.failed";
 * Uses the same registration shape as plugins so search, guidance, and tool
 * schemas treat these events like any other resource type.
 */
-function workspaceSnapshotResourceEvents() {
+function workspaceSnapshotEvents() {
 	return { resourceTypes: [{
 		type: WORKSPACE_SNAPSHOT_RESOURCE_TYPE,
 		supportedEvents: [WORKSPACE_SNAPSHOT_READY_EVENT, WORKSPACE_SNAPSHOT_FAILED_EVENT],
@@ -1588,62 +1588,66 @@ function workspaceSnapshotFinishedEvent(input) {
 	return event;
 }
 //#endregion
-//#region src/chat/resource-events/runtime-catalog.ts
+//#region src/chat/events/runtime-catalog.ts
 /**
-* Enabled resource-event registrations for search, guidance, and tool schemas.
+* Enabled event registrations for search, guidance, and tool schemas.
 *
 * Includes core Workspace snapshot events under the `junior` namespace, plus
 * every enabled plugin registration. Plugins may not use the `junior` namespace.
 */
-function getResourceEventCatalog() {
-	const catalog = { [CORE_RESOURCE_EVENT_NAMESPACE]: workspaceSnapshotResourceEvents() };
+function getEventCatalog() {
+	const catalog = { [CORE_EVENT_NAMESPACE]: workspaceSnapshotEvents() };
 	for (const plugin of getPlugins()) {
-		const registration = plugin.resourceEvents;
+		const registration = plugin.events;
 		if (!registration || registration.isEnabled?.() === false) continue;
-		if (plugin.manifest.name === "junior") throw new Error(`Plugin "${CORE_RESOURCE_EVENT_NAMESPACE}" cannot register resource events; that namespace is reserved for core Workspace snapshots`);
+		if (plugin.manifest.name === "junior") throw new Error(`Plugin "${CORE_EVENT_NAMESPACE}" cannot register events; that namespace is reserved for core Workspace snapshots`);
 		catalog[plugin.manifest.name] = registration;
 	}
 	return catalog;
 }
-/** Validate the persisted Slack creator identity for an event task. */
-const eventTaskPrincipalSchema = z.object({
+/** Validate the persisted Slack creator identity for an event automation. */
+const eventAutomationPrincipalSchema = z.object({
 	slackUserId: actorUserIdSchema,
 	fullName: z.string().optional(),
 	userName: z.string().optional()
 }).strict();
-/** Validate one persisted event-task selector and its presentation metadata. */
-const eventTaskTriggerSchema = z.object({
-	events: z.array(resourceEventTypeSchema).min(1),
+/** Validate one persisted event-automation selector and its presentation metadata. */
+const eventAutomationTriggerSchema = z.object({
+	events: z.array(eventTypeSchema).min(1),
 	label: z.string().min(1),
-	match: resourceEventMatchSchema.optional(),
+	match: eventMatchSchema.optional(),
 	namespace: z.string().min(1),
 	identifier: z.string().min(1).max(300),
 	resourceType: z.string().min(1)
 }).strict();
-/** Validate one persisted event task. */
-const eventTaskSchema = z.object({
+/** Validate one persisted event automation. */
+const eventAutomationSchema = z.object({
 	id: z.string().min(1),
 	createdAtMs: z.number().finite(),
-	createdBy: eventTaskPrincipalSchema,
+	createdBy: eventAutomationPrincipalSchema,
 	credentialMode: z.enum(["system", "creator"]),
 	destination: slackDestinationSchema,
 	destinationVisibility: destinationVisibilitySchema,
-	/** Visible effects after successful work. Missing legacy values send a message. */
-	outcomes: z.array(taskOutcomeSchema).max(5).optional(),
+	/** Explicit visible effects after successful work. An empty list is silent. */
+	outcomes: z.array(taskOutcomeSchema).max(5),
 	task: z.object({ text: z.string().min(1) }).strict(),
-	trigger: eventTaskTriggerSchema
+	trigger: eventAutomationTriggerSchema
 }).strict();
 //#endregion
-//#region src/chat/event-tasks/store.ts
+//#region src/chat/event-automations/store.ts
 /** JSON task payload must not carry SQL-backed columns. */
-function eventTaskJsonPayload(task) {
+function eventAutomationJsonPayload(task) {
 	const { status: _status, title: _title, ...payload } = task;
 	return payload;
 }
 function parseTask(row) {
 	const raw = row.task && typeof row.task === "object" ? { ...row.task } : row.task;
 	if (raw && typeof raw === "object" && "title" in raw) delete raw.title;
-	const payload = eventTaskSchema.parse(raw);
+	if (raw && typeof raw === "object" && !("outcomes" in raw) && "destination" in raw) raw.outcomes = [{
+		action: "send_message",
+		destination: raw.destination
+	}];
+	const payload = eventAutomationSchema.parse(raw);
 	const title = row.title?.trim();
 	return {
 		...payload,
@@ -1651,23 +1655,23 @@ function parseTask(row) {
 		...title ? { title } : void 0
 	};
 }
-function activeEventTaskWhere() {
-	return ne(juniorEventTasks.status, "deleted");
+function activeEventAutomationWhere() {
+	return ne(juniorEventAutomations.status, "deleted");
 }
-/** Read one event task by id, including deleted rows when present. */
-async function getEventTask(db, id) {
+/** Read one event automation by id, including deleted rows when present. */
+async function getEventAutomation(db, id) {
 	const rows = await db.select({
-		status: juniorEventTasks.status,
-		task: juniorEventTasks.task,
-		title: juniorEventTasks.title
-	}).from(juniorEventTasks).where(eq(juniorEventTasks.id, id)).limit(1);
+		status: juniorEventAutomations.status,
+		task: juniorEventAutomations.task,
+		title: juniorEventAutomations.title
+	}).from(juniorEventAutomations).where(eq(juniorEventAutomations.id, id)).limit(1);
 	return rows[0] ? parseTask(rows[0]) : void 0;
 }
-/** Create one retry-stable event task, or revive a deleted row with the new payload. */
-async function createEventTask(db, task) {
-	const parsed = eventTaskSchema.parse(eventTaskJsonPayload(task));
+/** Create one retry-stable event automation, or revive a deleted row with the new payload. */
+async function createEventAutomation(db, task) {
+	const parsed = eventAutomationSchema.parse(eventAutomationJsonPayload(task));
 	const title = task.title?.trim() || null;
-	await db.insert(juniorEventTasks).values({
+	await db.insert(juniorEventAutomations).values({
 		id: parsed.id,
 		teamId: parsed.destination.teamId,
 		namespace: parsed.trigger.namespace,
@@ -1677,118 +1681,118 @@ async function createEventTask(db, task) {
 		title,
 		task: parsed
 	}).onConflictDoNothing();
-	const existing = await getEventTask(db, parsed.id);
+	const existing = await getEventAutomation(db, parsed.id);
 	if (!existing) return {
 		...parsed,
 		status: "active",
 		...title ? { title } : void 0
 	};
 	if (existing.status !== "deleted") return existing;
-	const rows = await db.update(juniorEventTasks).set({
+	const rows = await db.update(juniorEventAutomations).set({
 		teamId: parsed.destination.teamId,
 		namespace: parsed.trigger.namespace,
 		identifier: parsed.trigger.identifier,
 		status: "active",
 		title,
 		task: parsed
-	}).where(and(eq(juniorEventTasks.id, parsed.id), eq(juniorEventTasks.status, "deleted"))).returning({
-		status: juniorEventTasks.status,
-		task: juniorEventTasks.task,
-		title: juniorEventTasks.title
+	}).where(and(eq(juniorEventAutomations.id, parsed.id), eq(juniorEventAutomations.status, "deleted"))).returning({
+		status: juniorEventAutomations.status,
+		task: juniorEventAutomations.task,
+		title: juniorEventAutomations.title
 	});
-	return rows[0] ? parseTask(rows[0]) : await getEventTask(db, parsed.id) ?? {
+	return rows[0] ? parseTask(rows[0]) : await getEventAutomation(db, parsed.id) ?? {
 		...parsed,
 		status: "active",
 		...title ? { title } : void 0
 	};
 }
-/** Replace an existing non-deleted event task. */
-async function saveEventTask(db, task) {
-	const parsed = eventTaskSchema.parse(eventTaskJsonPayload(task));
+/** Replace an existing non-deleted event automation. */
+async function saveEventAutomation(db, task) {
+	const parsed = eventAutomationSchema.parse(eventAutomationJsonPayload(task));
 	const title = task.title?.trim() || null;
-	const rows = await db.update(juniorEventTasks).set({
+	const rows = await db.update(juniorEventAutomations).set({
 		namespace: parsed.trigger.namespace,
 		identifier: parsed.trigger.identifier,
 		title,
 		task: parsed
-	}).where(and(eq(juniorEventTasks.id, parsed.id), activeEventTaskWhere())).returning({
-		status: juniorEventTasks.status,
-		task: juniorEventTasks.task,
-		title: juniorEventTasks.title
+	}).where(and(eq(juniorEventAutomations.id, parsed.id), activeEventAutomationWhere())).returning({
+		status: juniorEventAutomations.status,
+		task: juniorEventAutomations.task,
+		title: juniorEventAutomations.title
 	});
 	return rows[0] ? parseTask(rows[0]) : void 0;
 }
-/** Mark one existing event task deleted while retaining the row for history. */
-async function deleteEventTask(db, id) {
-	const rows = await db.update(juniorEventTasks).set({ status: "deleted" }).where(and(eq(juniorEventTasks.id, id), activeEventTaskWhere())).returning({
-		status: juniorEventTasks.status,
-		task: juniorEventTasks.task,
-		title: juniorEventTasks.title
+/** Mark one existing event automation deleted while retaining the row for history. */
+async function deleteEventAutomation(db, id) {
+	const rows = await db.update(juniorEventAutomations).set({ status: "deleted" }).where(and(eq(juniorEventAutomations.id, id), activeEventAutomationWhere())).returning({
+		status: juniorEventAutomations.status,
+		task: juniorEventAutomations.task,
+		title: juniorEventAutomations.title
 	});
 	return rows[0] ? parseTask(rows[0]) : void 0;
 }
-/** List live event tasks in one Slack workspace. */
-async function listEventTasksForTeam(db, teamId) {
+/** List live event automations in one Slack workspace. */
+async function listEventAutomationsForTeam(db, teamId) {
 	return (await db.select({
-		status: juniorEventTasks.status,
-		task: juniorEventTasks.task,
-		title: juniorEventTasks.title
-	}).from(juniorEventTasks).where(and(eq(juniorEventTasks.teamId, teamId), activeEventTaskWhere())).orderBy(asc(juniorEventTasks.createdAtMs), asc(juniorEventTasks.id))).map(parseTask);
+		status: juniorEventAutomations.status,
+		task: juniorEventAutomations.task,
+		title: juniorEventAutomations.title
+	}).from(juniorEventAutomations).where(and(eq(juniorEventAutomations.teamId, teamId), activeEventAutomationWhere())).orderBy(asc(juniorEventAutomations.createdAtMs), asc(juniorEventAutomations.id))).map(parseTask);
 }
 function viewerSlackIdentities(user) {
 	return user.identities.filter((identity) => identity.provider === "slack" && Boolean(identity.providerTenantId) && Boolean(identity.providerSubjectId));
 }
-/** Return whether one event task was created by a viewer-linked Slack identity. */
-function eventTaskBelongsToUser(task, user) {
+/** Return whether one event automation was created by a viewer-linked Slack identity. */
+function eventAutomationBelongsToUser(task, user) {
 	return viewerSlackIdentities(user).some((identity) => identity.providerTenantId === task.destination.teamId && identity.providerSubjectId === task.createdBy.slackUserId);
 }
-/** List a bounded newest-first page of live event tasks created by one user. */
-async function listEventTasksCreatedBy(db, user, limit, query) {
+/** List a bounded newest-first page of live event automations created by one user. */
+async function listEventAutomationsCreatedBy(db, user, limit, query) {
 	const identities = viewerSlackIdentities(user);
-	const ownership = or(...identities.map((identity) => and(eq(juniorEventTasks.teamId, identity.providerTenantId), sql`${juniorEventTasks.task}->'createdBy'->>'slackUserId' = ${identity.providerSubjectId}`)));
+	const ownership = or(...identities.map((identity) => and(eq(juniorEventAutomations.teamId, identity.providerTenantId), sql`${juniorEventAutomations.task}->'createdBy'->>'slackUserId' = ${identity.providerSubjectId}`)));
 	if (!ownership) return [];
 	return (await db.select({
-		status: juniorEventTasks.status,
-		task: juniorEventTasks.task,
-		title: juniorEventTasks.title
-	}).from(juniorEventTasks).where(and(ownership, activeEventTaskWhere(), query ? sql`strpos(lower(coalesce(${juniorEventTasks.title}, ${juniorEventTasks.task}->'task'->>'text')), ${query}) > 0` : void 0)).orderBy(desc(juniorEventTasks.createdAtMs), desc(juniorEventTasks.id)).limit(limit)).map(parseTask);
+		status: juniorEventAutomations.status,
+		task: juniorEventAutomations.task,
+		title: juniorEventAutomations.title
+	}).from(juniorEventAutomations).where(and(ownership, activeEventAutomationWhere(), query ? sql`strpos(lower(coalesce(${juniorEventAutomations.title}, ${juniorEventAutomations.task}->'task'->>'text')), ${query}) > 0` : void 0)).orderBy(desc(juniorEventAutomations.createdAtMs), desc(juniorEventAutomations.id)).limit(limit)).map(parseTask);
 }
 /**
-* List deleted event tasks created by one user, newest first.
-* Used only to keep historical runs after the live task list drops the row.
+* 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 listDeletedEventTasksCreatedBy(db, user, limit) {
+async function listDeletedEventAutomationsCreatedBy(db, user, limit) {
 	const identities = viewerSlackIdentities(user);
-	const ownership = or(...identities.map((identity) => and(eq(juniorEventTasks.teamId, identity.providerTenantId), sql`${juniorEventTasks.task}->'createdBy'->>'slackUserId' = ${identity.providerSubjectId}`)));
+	const ownership = or(...identities.map((identity) => and(eq(juniorEventAutomations.teamId, identity.providerTenantId), sql`${juniorEventAutomations.task}->'createdBy'->>'slackUserId' = ${identity.providerSubjectId}`)));
 	if (!ownership) return [];
 	return (await db.select({
-		status: juniorEventTasks.status,
-		task: juniorEventTasks.task,
-		title: juniorEventTasks.title
-	}).from(juniorEventTasks).where(and(ownership, eq(juniorEventTasks.status, "deleted"))).orderBy(desc(juniorEventTasks.createdAtMs), desc(juniorEventTasks.id)).limit(limit)).map(parseTask);
+		status: juniorEventAutomations.status,
+		task: juniorEventAutomations.task,
+		title: juniorEventAutomations.title
+	}).from(juniorEventAutomations).where(and(ownership, eq(juniorEventAutomations.status, "deleted"))).orderBy(desc(juniorEventAutomations.createdAtMs), desc(juniorEventAutomations.id)).limit(limit)).map(parseTask);
 }
-/** List live event tasks whose current Slack destination is public. */
-async function listPublicEventTasksForTeams(db, teamIds, limit, query) {
+/** List live event automations whose current Slack destination is public. */
+async function listPublicEventAutomationsForTeams(db, teamIds, limit, query) {
 	if (teamIds.length === 0) return [];
 	return (await db.select({
-		status: juniorEventTasks.status,
-		task: juniorEventTasks.task,
-		title: juniorEventTasks.title
-	}).from(juniorEventTasks).innerJoin(juniorDestinations, and(eq(juniorDestinations.provider, "slack"), eq(juniorDestinations.providerTenantId, juniorEventTasks.teamId), sql`${juniorDestinations.providerDestinationId} = ${juniorEventTasks.task}->'destination'->>'channelId'`)).where(and(inArray(juniorEventTasks.teamId, teamIds), activeEventTaskWhere(), query ? sql`strpos(lower(coalesce(${juniorEventTasks.title}, ${juniorEventTasks.task}->'task'->>'text')), ${query}) > 0` : void 0, eq(juniorDestinations.visibility, "public"))).orderBy(desc(juniorEventTasks.createdAtMs), desc(juniorEventTasks.id)).limit(limit)).map(parseTask);
+		status: juniorEventAutomations.status,
+		task: juniorEventAutomations.task,
+		title: juniorEventAutomations.title
+	}).from(juniorEventAutomations).innerJoin(juniorDestinations, and(eq(juniorDestinations.provider, "slack"), eq(juniorDestinations.providerTenantId, juniorEventAutomations.teamId), sql`${juniorDestinations.providerDestinationId} = ${juniorEventAutomations.task}->'destination'->>'channelId'`)).where(and(inArray(juniorEventAutomations.teamId, teamIds), activeEventAutomationWhere(), query ? sql`strpos(lower(coalesce(${juniorEventAutomations.title}, ${juniorEventAutomations.task}->'task'->>'text')), ${query}) > 0` : void 0, eq(juniorDestinations.visibility, "public"))).orderBy(desc(juniorEventAutomations.createdAtMs), desc(juniorEventAutomations.id)).limit(limit)).map(parseTask);
 }
 /**
-* Collect match keys from live event tasks for these identifiers and event types.
+* Collect match keys from live event automations for these identifiers and event types.
 * Does not evaluate match values — only reports keys that filters use.
 */
-async function collectEventTaskMatchKeys(db, input) {
+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.size === 0 || identifiers.length === 0) return [];
 	const rows = await db.select({
-		status: juniorEventTasks.status,
-		task: juniorEventTasks.task,
-		title: juniorEventTasks.title
-	}).from(juniorEventTasks).where(and(eq(juniorEventTasks.teamId, input.teamId), eq(juniorEventTasks.namespace, input.namespace), inArray(juniorEventTasks.identifier, identifiers), activeEventTaskWhere())).orderBy(asc(juniorEventTasks.createdAtMs), asc(juniorEventTasks.id));
+		status: juniorEventAutomations.status,
+		task: juniorEventAutomations.task,
+		title: juniorEventAutomations.title
+	}).from(juniorEventAutomations).where(and(eq(juniorEventAutomations.teamId, input.teamId), eq(juniorEventAutomations.namespace, input.namespace), inArray(juniorEventAutomations.identifier, identifiers), activeEventAutomationWhere())).orderBy(asc(juniorEventAutomations.createdAtMs), asc(juniorEventAutomations.id));
 	const keys = /* @__PURE__ */ new Set();
 	for (const row of rows) {
 		const task = parseTask(row);
@@ -1797,45 +1801,35 @@ async function collectEventTaskMatchKeys(db, input) {
 	}
 	return [...keys].sort();
 }
-/** Find every live task matching one normalized resource event. */
-async function findMatchingEventTasks(db, event, teamId) {
+/** Find every live task matching one normalized event. */
+async function findMatchingEventAutomations(db, event, teamId) {
 	return (await db.select({
-		status: juniorEventTasks.status,
-		task: juniorEventTasks.task,
-		title: juniorEventTasks.title
-	}).from(juniorEventTasks).where(and(eq(juniorEventTasks.teamId, teamId), eq(juniorEventTasks.namespace, event.namespace), eq(juniorEventTasks.identifier, event.identifier), activeEventTaskWhere())).orderBy(asc(juniorEventTasks.createdAtMs), asc(juniorEventTasks.id))).map(parseTask).filter((task) => task.trigger.events.includes(event.eventType) && resourceEventMatches(task.trigger.match, event.data));
+		status: juniorEventAutomations.status,
+		task: juniorEventAutomations.task,
+		title: juniorEventAutomations.title
+	}).from(juniorEventAutomations).where(and(eq(juniorEventAutomations.teamId, teamId), eq(juniorEventAutomations.namespace, event.namespace), eq(juniorEventAutomations.identifier, event.identifier), activeEventAutomationWhere())).orderBy(asc(juniorEventAutomations.createdAtMs), asc(juniorEventAutomations.id))).map(parseTask).filter((task) => task.trigger.events.includes(event.eventType) && eventMatches(task.trigger.match, event.data));
 }
 //#endregion
 //#region src/chat/task-outcomes.ts
-const taskMessageDestinationInputSchema = z.union([slackDestinationSchema, z.object({
-	platform: z.literal("slack"),
-	teamId: z.string().min(1),
-	userId: actorUserIdSchema
-}).strict()]);
+const taskMessageDestinationInputSchema = z.enum(["current_conversation", "task_creator"]).describe("Where to send the message. Use current_conversation for posts, digests, summaries, and channel reminders. Use task_creator only when the user asks for a direct reminder or notification.");
 /** Input accepted by task authoring tools before a user becomes a DM Destination. */
 const taskOutcomeInputSchema = z.object({
 	action: z.literal("send_message"),
 	destination: taskMessageDestinationInputSchema
 }).strict();
-/** Resolve tool input to the Slack Destinations stored on a task. */
+/** Resolve explicit message outcomes to the Slack Destinations stored on an Automation. */
 async function resolveTaskOutcomes(outcomes, currentDestination, creatorSlackUserId) {
-	if (outcomes === void 0) return [{
-		action: "send_message",
-		destination: currentDestination
-	}];
+	if (outcomes === void 0) return [];
 	const resolved = [];
 	for (const outcome of outcomes) {
-		if (outcome.destination.teamId !== currentDestination.teamId) throw new Error("Message destinations must be in the current Slack workspace.");
-		if ("channelId" in outcome.destination) {
-			if (outcome.destination.channelId !== currentDestination.channelId) throw new Error("Messages can only be sent to the current Slack conversation or the task creator.");
+		if (outcome.destination === "current_conversation") {
 			resolved.push({
 				action: "send_message",
 				destination: currentDestination
 			});
 			continue;
 		}
-		const userId = outcome.destination.userId;
-		if (userId !== creatorSlackUserId) throw new Error("Direct messages can only be sent to the task creator.");
+		const userId = creatorSlackUserId;
 		const channelId = (await withSlackRetries(() => getSlackClient().conversations.open({ users: userId }), 3, { action: "conversations.open" })).channel?.id;
 		if (!channelId) throw new Error("Slack did not return a direct message destination.");
 		resolved.push({
@@ -1852,12 +1846,9 @@ async function resolveTaskOutcomes(outcomes, currentDestination, creatorSlackUse
 function outcomeTargetsDestination(outcome, destination) {
 	return outcome.destination.teamId === destination.teamId && outcome.destination.channelId === destination.channelId && (!outcome.destination.threadTs || outcome.destination.threadTs === destination.threadTs);
 }
-/** Return outcomes with legacy same-channel messages bound to the task Destination. */
+/** Bind same-channel message outcomes to the Automation Destination. */
 function effectiveTaskOutcomes(outcomes, destination) {
-	return (outcomes ?? [{
-		action: "send_message",
-		destination
-	}]).map((outcome) => destination.threadTs && outcomeTargetsDestination(outcome, destination) ? {
+	return outcomes.map((outcome) => destination.threadTs && outcomeTargetsDestination(outcome, destination) ? {
 		...outcome,
 		destination
 	} : outcome);
@@ -1870,53 +1861,66 @@ function moveTaskOutcomes(outcomes, currentDestination, nextDestination) {
 	} : outcome);
 }
 //#endregion
-//#region src/chat/event-tasks/tool-support.ts
-const compactEventTaskResultSchema = z.object({
+//#region src/chat/event-automations/tool-support.ts
+const compactEventAutomationResultSchema = z.object({
 	id: z.string().min(1),
-	task: z.string().min(1),
-	namespace: z.string().min(1),
-	identifier: z.string().min(1),
-	resourceType: z.string().min(1),
-	label: z.string().min(1),
-	events: z.array(z.string().min(1)).min(1),
-	match: z.record(z.string(), z.unknown()).optional(),
+	title: z.string().min(1).nullable(),
+	instruction: z.string().min(1),
+	trigger: z.object({
+		namespace: z.string().min(1),
+		identifier: z.string().min(1),
+		resourceType: z.string().min(1),
+		label: z.string().min(1),
+		events: z.array(z.string().min(1)).min(1),
+		match: z.record(z.string(), z.unknown()).optional(),
+		available: z.boolean()
+	}).strict(),
 	credentialMode: z.enum(["system", "creator"]),
-	outcomes: z.array(taskOutcomeSchema).max(5),
-	createdBy: eventTaskPrincipalSchema,
-	triggerAvailable: z.boolean()
+	isCreator: z.boolean(),
+	outcomes: z.array(z.object({
+		action: z.literal("send_message"),
+		destination: z.object({
+			channel: z.string().min(1),
+			thread: z.string().min(1).nullable()
+		}).strict()
+	}).strict()).max(5),
+	createdBy: z.object({
+		name: z.string().min(1).nullable(),
+		username: z.string().min(1).nullable()
+	}).strict()
 }).strict();
-/** Validate one successful event-task mutation result. */
-const eventTaskToolResultSchema = juniorToolOutputSchema.extend({ task: compactEventTaskResultSchema }).strict();
-/** Validate one successful event-task list result. */
-const eventTaskListToolResultSchema = juniorToolOutputSchema.extend({
-	tasks: z.array(compactEventTaskResultSchema),
+/** Validate one successful event-automation mutation result. */
+const eventAutomationToolResultSchema = juniorToolOutputSchema.extend({ automation: compactEventAutomationResultSchema }).strict();
+/** Validate one successful event-automation list result. */
+const eventAutomationListToolResultSchema = juniorToolOutputSchema.extend({
+	automations: z.array(compactEventAutomationResultSchema),
 	truncated: z.boolean()
 }).strict();
-/** Build the validated resource-event trigger accepted by event-task tools. */
-function registeredEventTaskTriggerSchema(catalog) {
-	const plugins = pluginResourceEventCatalog(catalog);
+/** Build the validated event trigger accepted by event-automation tools. */
+function registeredEventAutomationTriggerSchema(catalog) {
+	const plugins = pluginEventCatalog(catalog);
 	return z.object({
 		namespace: eventNamespaceSchema(plugins),
 		identifier: z.string().trim().min(1).max(300),
 		resourceType: registeredResourceTypeSchema(plugins),
 		label: z.string().trim().min(1).max(500),
 		events: z.array(registeredEventTypeSchema(plugins)).min(1),
-		match: registeredResourceEventMatchSchema()
+		match: registeredEventMatchSchema()
 	}).strict();
 }
-/** Reject an event-task trigger that is no longer supported by the catalog. */
-function requireSupportedEventTaskTrigger(catalog, trigger) {
-	const plugins = pluginResourceEventCatalog(catalog);
+/** Reject an event-automation trigger that is no longer supported by the catalog. */
+function requireSupportedEventAutomationTrigger(catalog, trigger) {
+	const plugins = pluginEventCatalog(catalog);
 	for (const eventType of trigger.events) if (!pluginSupportsEvent(plugins, trigger.namespace, trigger.resourceType, eventType)) throw new ToolInputError(`Resource type "${trigger.namespace}:${trigger.resourceType}" does not support event "${eventType}".`);
-	return requireSupportedResourceEventMatch(plugins, {
+	return requireSupportedEventMatch(plugins, {
 		match: trigger.match,
 		namespace: trigger.namespace,
 		resourceType: trigger.resourceType
 	});
 }
-/** Require the active Slack authority used for event-task management. */
-function requireEventTaskSlackContext(context) {
-	if (context.source.kind !== "slack" || context.destination.platform !== "slack" || context.actor?.platform !== "slack" || context.actor.teamId !== context.source.teamId) throw new ToolInputError("Event tasks require an active Slack channel or DM and actor.");
+/** Require the active Slack authority used for event-automation management. */
+function requireEventAutomationSlackContext(context) {
+	if (context.source.kind !== "slack" || context.destination.platform !== "slack" || context.actor?.platform !== "slack" || context.actor.teamId !== context.source.teamId) throw new ToolInputError("Event automations require an active Slack channel or DM and actor.");
 	return {
 		actor: context.actor,
 		destination: {
@@ -1928,61 +1932,74 @@ function requireEventTaskSlackContext(context) {
 		source: context.source
 	};
 }
-/** Return whether an event task belongs to the active Slack destination. */
-function eventTaskMatchesDestination(task, destination) {
+/** Return whether an event automation belongs to the active Slack destination. */
+function eventAutomationMatchesDestination(task, destination) {
 	return task.destination.teamId === destination.teamId && task.destination.channelId === destination.channelId;
 }
 /**
-* Return whether the active destination may update or delete this task.
-* Same-destination tasks stay local. Public tasks may be managed by id from
+* Return whether the active destination may update or delete this automation.
+* Same-destination automations stay local. Public automations may be managed by id from
 * another destination in the same workspace.
 */
-function eventTaskIsWritableFrom(task, destination) {
+function eventAutomationIsWritableFrom(task, destination) {
 	if (task.destination.teamId !== destination.teamId) return false;
 	return task.destination.channelId === destination.channelId || task.destinationVisibility === "public";
 }
-/** Load one task the active destination may update or delete. */
-async function writableEventTask(context, id) {
-	const { destination } = requireEventTaskSlackContext(context);
-	const task = await getEventTask(getDb(), id);
-	if (!task || task.status === "deleted" || !eventTaskIsWritableFrom(task, destination)) throw new ToolInputError("Event task was not found.");
+/** Load one automation the active destination may update or delete. */
+async function writableEventAutomation(context, id) {
+	const { destination } = requireEventAutomationSlackContext(context);
+	const task = await getEventAutomation(getDb(), id);
+	if (!task || task.status === "deleted" || !eventAutomationIsWritableFrom(task, destination)) throw new ToolInputError("Event automation was not found.");
 	return task;
 }
-function eventTaskTriggerAvailable(task, catalog) {
-	const registration = pluginResourceEventCatalog(catalog)[task.trigger.namespace];
+function eventAutomationTriggerAvailable(task, catalog) {
+	const registration = pluginEventCatalog(catalog)[task.trigger.namespace];
 	return Boolean(registration && task.trigger.events.every((eventType) => registration.resourceTypes.some((resourceType) => resourceType.supportedEvents.includes(eventType))));
 }
-/** Project an event task into the bounded tool-result shape. */
-function compactEventTask(task, catalog) {
-	return compactEventTaskResultSchema.parse({
+/** Project an event automation into the bounded tool-result shape. */
+function compactEventAutomation(task, catalog, requesterSlackUserId) {
+	return compactEventAutomationResultSchema.parse({
 		id: task.id,
-		task: task.task.text,
-		namespace: task.trigger.namespace,
-		identifier: task.trigger.identifier,
-		resourceType: task.trigger.resourceType,
-		label: task.trigger.label,
-		events: task.trigger.events,
-		...task.trigger.match ? { match: task.trigger.match } : void 0,
+		title: task.title?.trim() || null,
+		instruction: task.task.text,
+		trigger: {
+			namespace: task.trigger.namespace,
+			identifier: task.trigger.identifier,
+			resourceType: task.trigger.resourceType,
+			label: task.trigger.label,
+			events: task.trigger.events,
+			...task.trigger.match ? { match: task.trigger.match } : void 0,
+			available: eventAutomationTriggerAvailable(task, catalog)
+		},
 		credentialMode: task.credentialMode,
-		outcomes: effectiveTaskOutcomes(task.outcomes, task.destination),
-		createdBy: task.createdBy,
-		triggerAvailable: eventTaskTriggerAvailable(task, catalog)
+		isCreator: task.createdBy.slackUserId === requesterSlackUserId,
+		outcomes: effectiveTaskOutcomes(task.outcomes, task.destination).map((outcome) => ({
+			action: outcome.action,
+			destination: {
+				channel: outcome.destination.channelId,
+				thread: outcome.destination.threadTs ?? null
+			}
+		})),
+		createdBy: {
+			name: task.createdBy.fullName ?? null,
+			username: task.createdBy.userName ?? null
+		}
 	});
 }
-/** Return the standard successful event-task tool result. */
-function eventTaskSuccess(task, catalog) {
-	return { task: compactEventTask(task, catalog) };
+/** Return the standard successful event-automation tool result. */
+function eventAutomationToolResult(task, catalog, requesterSlackUserId) {
+	return { automation: compactEventAutomation(task, catalog, requesterSlackUserId) };
 }
 //#endregion
-//#region src/chat/scheduled-tasks/types.ts
-/** Durable scheduled-task domain types owned by Junior core. */
-const scheduledTaskStatusSchema = z.enum([
+//#region src/chat/scheduled-automations/types.ts
+/** Durable scheduled-automation domain types owned by Junior core. */
+const scheduledAutomationStatusSchema = z.enum([
 	"active",
 	"blocked",
 	"completed",
 	"deleted"
 ]);
-const scheduledTaskCredentialModeSchema = z.enum(["system", "creator"]);
+const scheduledAutomationCredentialModeSchema = z.enum(["system", "creator"]);
 const scheduledRunStatusSchema = z.enum([
 	"pending",
 	"running",
@@ -1991,12 +2008,12 @@ const scheduledRunStatusSchema = z.enum([
 	"blocked",
 	"skipped"
 ]);
-const scheduledTaskPrincipalSchema = z.object({
+const scheduledAutomationPrincipalSchema = z.object({
 	slackUserId: actorUserIdSchema,
 	fullName: z.string().optional(),
 	userName: z.string().optional()
 }).strict();
-const scheduledTaskRecurrenceSchema = z.object({
+const scheduledAutomationRecurrenceSchema = z.object({
 	dayOfMonth: z.number().optional(),
 	frequency: z.enum([
 		"daily",
@@ -2013,18 +2030,18 @@ const scheduledTaskRecurrenceSchema = z.object({
 	}).strict(),
 	weekdays: z.array(z.number()).optional()
 }).strict();
-const scheduledTaskScheduleSchema = z.object({
+const scheduledAutomationScheduleSchema = z.object({
 	description: z.string(),
 	kind: z.enum(["one_off", "recurring"]),
-	recurrence: scheduledTaskRecurrenceSchema.optional(),
+	recurrence: scheduledAutomationRecurrenceSchema.optional(),
 	timezone: z.string()
 }).strict();
-const scheduledTaskExecutionActorSchema = z.object({
+const scheduledAutomationExecutionActorSchema = z.object({
 	platform: z.literal("system"),
 	name: z.string()
 }).strict();
-/** Validate the current scheduled-task domain shape. */
-const scheduledTaskSchema = z.object({
+/** Validate the current scheduled-automation domain shape. */
+const scheduledAutomationSchema = z.object({
 	id: z.string(),
 	conversationAccess: z.object({
 		audience: z.enum([
@@ -2035,22 +2052,22 @@ const scheduledTaskSchema = z.object({
 		visibility: z.enum(["private", "public"])
 	}).strict(),
 	createdAtMs: z.number(),
-	createdBy: scheduledTaskPrincipalSchema,
+	createdBy: scheduledAutomationPrincipalSchema,
 	/** Authoritative provider identity that created the task. */
 	creatorIdentityId: z.string(),
 	/** Selects system credentials or task-bound creator credential delegation. */
-	credentialMode: scheduledTaskCredentialModeSchema,
+	credentialMode: scheduledAutomationCredentialModeSchema,
 	destination: slackDestinationSchema,
-	executionActor: scheduledTaskExecutionActorSchema.optional(),
+	executionActor: scheduledAutomationExecutionActorSchema.optional(),
 	lastRunAtMs: z.number().optional(),
 	nextRunAtMs: z.number().optional(),
 	originalRequest: z.string().optional(),
 	runNowAtMs: z.number().optional(),
-	schedule: scheduledTaskScheduleSchema,
-	status: scheduledTaskStatusSchema,
+	schedule: scheduledAutomationScheduleSchema,
+	status: scheduledAutomationStatusSchema,
 	statusReason: z.string().optional(),
-	/** Visible effects after successful work. Missing legacy values send a message. */
-	outcomes: z.array(taskOutcomeSchema).max(5).optional(),
+	/** Explicit visible effects after successful work. An empty list is silent. */
+	outcomes: z.array(taskOutcomeSchema).max(5),
 	task: z.object({ text: z.string() }).strict(),
 	/** SQL-backed short display title generated from the task instruction. */
 	title: z.string().optional(),
@@ -2070,14 +2087,14 @@ const scheduledRunSchema = z.object({
 	status: scheduledRunStatusSchema,
 	taskId: z.string()
 }).strict();
-const SCHEDULED_TASK_SYSTEM_ACTOR = Object.freeze({
+const SCHEDULED_AUTOMATION_SYSTEM_ACTOR = Object.freeze({
 	platform: "system",
-	name: "scheduled-task"
+	name: "scheduled-automation"
 });
 //#endregion
-//#region src/chat/scheduled-tasks/tasks.ts
+//#region src/chat/scheduled-automations/tasks.ts
 const SCHEDULER_KEY_PREFIX = "junior:scheduler";
-const retainedScheduledTaskSchema = scheduledTaskSchema.omit({
+const retainedScheduledAutomationSchema = scheduledAutomationSchema.omit({
 	creatorIdentityId: true,
 	title: true
 }).extend({
@@ -2091,11 +2108,18 @@ const retainedScheduledTaskSchema = scheduledTaskSchema.omit({
 	version: z.number().optional()
 }).strict();
 /** Decode a retained scheduler task row and reject invalid routing context. */
-function parseScheduledTaskRow(row) {
+function parseScheduledAutomationRow(row) {
 	const record = z.record(z.string(), z.unknown()).safeParse(row.record);
 	if (!record.success) return void 0;
 	const { creatorIdentityId: legacyCreatorIdentityId, title: legacyTitle, ...retained } = record.data;
-	const parsed = retainedScheduledTaskSchema.safeParse(retained);
+	const current = retained.outcomes === void 0 && retained.destination !== void 0 ? {
+		...retained,
+		outcomes: [{
+			action: "send_message",
+			destination: retained.destination
+		}]
+	} : retained;
+	const parsed = retainedScheduledAutomationSchema.safeParse(current);
 	if (!parsed.success) return void 0;
 	const { status, version: _version, ...task } = parsed.data;
 	const fallbackIdentity = row.creatorIdentityId === null ? z.string().safeParse(legacyCreatorIdentityId) : void 0;
@@ -2120,23 +2144,23 @@ function parseScheduledTaskRow(row) {
 	};
 }
 /** Keep scan paths from returning current or legacy tombstones. */
-function isListedScheduledTask(task) {
+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 task. */
-function withScheduledTaskLock(db, taskId, callback) {
+/** 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 = scheduledTaskSchema.safeParse(task);
-	if (!parsed.success) throw new Error("Scheduled task routing context is invalid.");
+	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 {
@@ -2144,11 +2168,11 @@ function requireStoredTask(task) {
 		...normalizedTitle ? { title: normalizedTitle } : void 0
 	};
 }
-function scheduledTaskJsonRecord(task) {
+function scheduledAutomationJsonRecord(task) {
 	const { title: _title, ...record } = task;
 	return record;
 }
-async function upsertScheduledTask(db, task) {
+async function upsertScheduledAutomation(db, task) {
 	const title = task.title?.trim() || null;
 	await db.insert(juniorSchedulerTasks).values({
 		createdAtMs: task.createdAtMs,
@@ -2156,7 +2180,7 @@ async function upsertScheduledTask(db, task) {
 		creatorSlackUserId: task.createdBy.slackUserId,
 		id: task.id,
 		nextRunAtMs: task.nextRunAtMs,
-		record: scheduledTaskJsonRecord(task),
+		record: scheduledAutomationJsonRecord(task),
 		runNowAtMs: task.runNowAtMs,
 		status: task.status,
 		teamId: task.destination.teamId,
@@ -2176,37 +2200,37 @@ async function upsertScheduledTask(db, task) {
 		}
 	});
 }
-/** Read and decode one scheduled task. */
-async function readScheduledTask(db, taskId) {
+/** Read and decode one scheduled automation. */
+async function readScheduledAutomation(db, taskId) {
 	const rows = await db.select({
 		creatorIdentityId: juniorSchedulerTasks.creatorIdentityId,
 		record: juniorSchedulerTasks.record,
 		title: juniorSchedulerTasks.title
 	}).from(juniorSchedulerTasks).where(eq(juniorSchedulerTasks.id, taskId)).limit(1);
-	return rows[0] ? parseScheduledTaskRow(rows[0]) : void 0;
+	return rows[0] ? parseScheduledAutomationRow(rows[0]) : void 0;
 }
-async function readListedScheduledTasks(db, teamId) {
+async function readListedScheduledAutomations(db, teamId) {
 	return (await db.select({
 		creatorIdentityId: juniorSchedulerTasks.creatorIdentityId,
 		record: juniorSchedulerTasks.record,
 		title: juniorSchedulerTasks.title
-	}).from(juniorSchedulerTasks).where(and(notInArray(juniorSchedulerTasks.status, ["deleted", "paused"]), teamId === void 0 ? void 0 : eq(juniorSchedulerTasks.teamId, teamId))).orderBy(asc(juniorSchedulerTasks.createdAtMs), asc(juniorSchedulerTasks.id))).map(parseScheduledTaskRow).filter(isListedScheduledTask);
+	}).from(juniorSchedulerTasks).where(and(notInArray(juniorSchedulerTasks.status, ["deleted", "paused"]), teamId === void 0 ? void 0 : eq(juniorSchedulerTasks.teamId, teamId))).orderBy(asc(juniorSchedulerTasks.createdAtMs), asc(juniorSchedulerTasks.id))).map(parseScheduledAutomationRow).filter(isListedScheduledAutomation);
 }
-/** List decoded scheduled tasks in stable creation order. */
-async function listScheduledTasks(db) {
-	return await readListedScheduledTasks(db);
+/** List decoded scheduled automations in stable creation order. */
+async function listScheduledAutomations(db) {
+	return await readListedScheduledAutomations(db);
 }
-/** List decoded scheduled tasks for one team in stable creation order. */
-async function listScheduledTasksForTeam(db, teamId) {
-	return await readListedScheduledTasks(db, teamId);
+/** List decoded scheduled automations for one team in stable creation order. */
+async function listScheduledAutomationsForTeam(db, teamId) {
+	return await readListedScheduledAutomations(db, teamId);
 }
-async function writeScheduledTask(db, task, current) {
+async function writeScheduledAutomation(db, task, current) {
 	if (current?.status === "blocked" && task.status === "active" && typeof task.nextRunAtMs === "number" && Number.isFinite(task.nextRunAtMs)) await db.delete(juniorSchedulerRuns).where(and(eq(juniorSchedulerRuns.id, scheduledRunId(task.id, task.nextRunAtMs)), eq(juniorSchedulerRuns.status, "blocked")));
 	if (task.status === "deleted" && current?.status !== "deleted") await skipPendingRunsForDeletedTask(db, task);
-	await upsertScheduledTask(db, task);
+	await upsertScheduledAutomation(db, task);
 }
 async function skipPendingRunsForDeletedTask(db, task) {
-	const errorMessage = `Scheduled task ${task.id} was deleted before the run started.`;
+	const errorMessage = `Scheduled automation ${task.id} was deleted before the run started.`;
 	const rows = await db.select({ record: juniorSchedulerRuns.record }).from(juniorSchedulerRuns).where(and(eq(juniorSchedulerRuns.taskId, task.id), eq(juniorSchedulerRuns.status, "pending")));
 	for (const row of rows) {
 		const parsed = scheduledRunSchema.safeParse(row.record);
@@ -2223,31 +2247,31 @@ async function skipPendingRunsForDeletedTask(db, task) {
 		}).where(and(eq(juniorSchedulerRuns.id, next.id), eq(juniorSchedulerRuns.status, "pending")));
 	}
 }
-/** Create a scheduled task once under its retry-stable task lock. */
-async function createScheduledTask(db, task) {
+/** Create a scheduled automation once under its retry-stable task lock. */
+async function createScheduledAutomation(db, task) {
 	const next = requireStoredTask(task);
-	return await withScheduledTaskLock(db, task.id, async (tx) => {
-		const current = await readScheduledTask(tx, task.id);
+	return await withScheduledAutomationLock(db, task.id, async (tx) => {
+		const current = await readScheduledAutomation(tx, task.id);
 		if (current) return current;
-		await writeScheduledTask(tx, next, void 0);
+		await writeScheduledAutomation(tx, next, void 0);
 		return next;
 	});
 }
-/** Save a scheduled task and clear its blocked occurrence on reactivation. */
-async function saveScheduledTask(db, task) {
+/** Save a scheduled automation and clear its blocked occurrence on reactivation. */
+async function saveScheduledAutomation(db, task) {
 	const next = requireStoredTask(task);
-	await withScheduledTaskLock(db, task.id, async (tx) => {
-		const current = await readScheduledTask(tx, task.id);
-		await writeScheduledTask(tx, next, current);
+	await withScheduledAutomationLock(db, task.id, async (tx) => {
+		const current = await readScheduledAutomation(tx, task.id);
+		await writeScheduledAutomation(tx, next, current);
 	});
 	return next;
 }
-/** Save a scheduled task inside a task lock already held by the caller. */
-async function saveScheduledTaskInLock(db, task, current) {
-	await writeScheduledTask(db, requireStoredTask(task), current);
+/** 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);
 }
-/** List scheduled tasks whose current Slack destination is public. */
-async function listPublicScheduledTasksForTeams(db, teamIds, input) {
+/** List scheduled automations whose current Slack destination is public. */
+async function listPublicScheduledAutomationsForTeams(db, teamIds, input) {
 	if (teamIds.length === 0) return [];
 	return (await db.select({
 		creatorIdentityId: juniorSchedulerTasks.creatorIdentityId,
@@ -2257,7 +2281,7 @@ async function listPublicScheduledTasksForTeams(db, teamIds, input) {
 		"completed",
 		"deleted",
 		"paused"
-	]), input.query ? sql`strpos(lower(coalesce(${juniorSchedulerTasks.title}, ${juniorSchedulerTasks.record}->'task'->>'text')), ${input.query}) > 0` : void 0, eq(juniorDestinations.visibility, "public"))).orderBy(desc(juniorSchedulerTasks.createdAtMs), desc(juniorSchedulerTasks.id)).limit(input.limit)).map(parseScheduledTaskRow).filter(isListedScheduledTask);
+	]), input.query ? sql`strpos(lower(coalesce(${juniorSchedulerTasks.title}, ${juniorSchedulerTasks.record}->'task'->>'text')), ${input.query}) > 0` : void 0, eq(juniorDestinations.visibility, "public"))).orderBy(desc(juniorSchedulerTasks.createdAtMs), desc(juniorSchedulerTasks.id)).limit(input.limit)).map(parseScheduledAutomationRow).filter(isListedScheduledAutomation);
 }
 //#endregion
 //#region src/chat/slack/context.ts
@@ -2645,4 +2669,4 @@ async function readStats(start, end) {
 	return await getDb().select().from(juniorStats).where(and(gte(juniorStats.date, start), lte(juniorStats.date, end))).orderBy(asc(juniorStats.date), asc(juniorStats.namespace), asc(juniorStats.metric), asc(juniorStats.name));
 }
 //#endregion
-export { workspaceSnapshotFinishedEvent as $, eventTaskTriggerAvailable as A, recordConversationRetry as At, createEventTask as B, isFinalAttempt as Bt, SCHEDULED_TASK_SYSTEM_ACTOR as C, drainConversationMailbox as Ct, eventTaskMatchesDestination as D, hasRunnableConversationWork as Dt, eventTaskListToolResultSchema as E, getConversationWorkState as Et, effectiveTaskOutcomes as F, startConversationWork as Ft, listDeletedEventTasksCreatedBy as G, buildDeterministicAssistantMessageId as Gt, eventTaskBelongsToUser as H, injectContinuationToolName as Ht, moveTaskOutcomes as I, stopConversationWork as It, listPublicEventTasksForTeams as J, listEventTasksCreatedBy as K, buildDeterministicTurnId as Kt, resolveTaskOutcomes as L, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS as Lt, requireEventTaskSlackContext as M, removeActiveConversation as Mt, requireSupportedEventTaskTrigger as N, requestAnotherSlice as Nt, eventTaskSuccess as O, listActiveConversationIds as Ot, writableEventTask as P, requestConversationWork as Pt, WORKSPACE_SNAPSHOT_READY_EVENT as Q, taskOutcomeInputSchema as R, CONVERSATION_WORK_STALE_ENQUEUE_MS as Rt, withScheduledTaskLock as S, deadLetterAttempt as St, compactEventTask as T, getConversation as Tt, findMatchingEventTasks as U, juniorToolOutputSchema as Ut, deleteEventTask as V, isInvalidConversationRecordError as Vt, getEventTask as W, makeStructuredToolOutput as Wt, getResourceEventCatalog as X, saveEventTask as Y, WORKSPACE_SNAPSHOT_FAILED_EVENT as Z, parseScheduledTaskRow as _, clearConsumedConversationWake as _t, requestAttachmentDeletion as a, pluginSupportsEvent as at, saveScheduledTaskInLock as b, completeConversationWork as bt, parseSlackThreadId as c, registeredResourceTypeSchema as ct, resolveSlackChannelIdFromThreadId as d, ackMessages as dt, workspaceSnapshotWatch as et, createScheduledTask as f, appendAndEnqueueExclusiveInboundMessage as ft, listScheduledTasksForTeam as g, checkInConversationWork as gt, listScheduledTasks as h, cancelHumanFacingPendingMessages as ht, readLiveAttachment as i, normalizeEventIdentifier as it, registeredEventTaskTriggerSchema as j, releaseConversationWork as jt, eventTaskToolResultSchema as k, recordAttemptFailure as kt, readSlackRawMessageContext as l, requireSupportedResourceEventMatch as lt, listPublicScheduledTasksForTeams as m, beginConversationResume as mt, readStats as n, hasPluginResourceEventCatalogEntries as nt, storeAttachment as o, registeredEventTypeSchema as ot, isListedScheduledTask as p, appendAndEnqueueInboundMessage as pt, listEventTasksForTeam as q, collectAttachmentGarbage as r, hasResourceEventCatalogEntries as rt, storeAttachments as s, registeredResourceEventMatchSchema as st, incrementStat as t, eventNamespaceSchema as tt, resolveSlackChannelIdFromMessage as u, resourceEventGuidance as ut, readScheduledTask as v, clearExpiredConversationLease as vt, scheduledRunSchema as w, ensureConversationWake as wt, scheduledRunId as x, countPendingConversationMessages as xt, saveScheduledTask as y, completeConversationStop as yt, collectEventTaskMatchKeys as z, hasRunnableConversationWork$1 as zt };
+export { workspaceSnapshotFinishedEvent as $, eventAutomationTriggerAvailable as A, recordConversationRetry as At, createEventAutomation as B, isFinalAttempt as Bt, SCHEDULED_AUTOMATION_SYSTEM_ACTOR as C, drainConversationMailbox as Ct, eventAutomationMatchesDestination as D, hasRunnableConversationWork as Dt, eventAutomationListToolResultSchema as E, getConversationWorkState as Et, effectiveTaskOutcomes as F, startConversationWork as Ft, listDeletedEventAutomationsCreatedBy as G, buildDeterministicAssistantMessageId as Gt, eventAutomationBelongsToUser as H, injectContinuationToolName as Ht, moveTaskOutcomes as I, stopConversationWork as It, listPublicEventAutomationsForTeams as J, listEventAutomationsCreatedBy as K, buildDeterministicTurnId as Kt, resolveTaskOutcomes as L, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS as Lt, requireEventAutomationSlackContext as M, removeActiveConversation as Mt, requireSupportedEventAutomationTrigger as N, requestAnotherSlice as Nt, eventAutomationToolResult as O, listActiveConversationIds as Ot, writableEventAutomation as P, requestConversationWork as Pt, WORKSPACE_SNAPSHOT_READY_EVENT as Q, taskOutcomeInputSchema as R, CONVERSATION_WORK_STALE_ENQUEUE_MS as Rt, withScheduledAutomationLock as S, deadLetterAttempt as St, compactEventAutomation as T, getConversation as Tt, findMatchingEventAutomations as U, juniorToolOutputSchema as Ut, deleteEventAutomation as V, isInvalidConversationRecordError as Vt, getEventAutomation as W, makeStructuredToolOutput as Wt, getEventCatalog as X, saveEventAutomation as Y, WORKSPACE_SNAPSHOT_FAILED_EVENT as Z, parseScheduledAutomationRow as _, clearConsumedConversationWake as _t, requestAttachmentDeletion as a, normalizeCatalogEventIdentifier as at, saveScheduledAutomationInLock as b, completeConversationWork as bt, parseSlackThreadId as c, registeredEventTypeSchema as ct, resolveSlackChannelIdFromThreadId as d, ackMessages as dt, workspaceSnapshotWatch as et, createScheduledAutomation as f, appendAndEnqueueExclusiveInboundMessage as ft, listScheduledAutomationsForTeam as g, checkInConversationWork as gt, listScheduledAutomations as h, cancelHumanFacingPendingMessages as ht, readLiveAttachment as i, hasPluginEventCatalogEntries as it, registeredEventAutomationTriggerSchema as j, releaseConversationWork as jt, eventAutomationToolResultSchema as k, recordAttemptFailure as kt, readSlackRawMessageContext as l, registeredResourceTypeSchema as lt, listPublicScheduledAutomationsForTeams as m, beginConversationResume as mt, readStats as n, eventNamespaceSchema as nt, storeAttachment as o, pluginSupportsEvent as ot, isListedScheduledAutomation as p, appendAndEnqueueInboundMessage as pt, listEventAutomationsForTeam as q, collectAttachmentGarbage as r, hasEventCatalogEntries as rt, storeAttachments as s, registeredEventMatchSchema as st, incrementStat as t, eventGuidance as tt, resolveSlackChannelIdFromMessage as u, requireSupportedEventMatch as ut, readScheduledAutomation as v, clearExpiredConversationLease as vt, scheduledRunSchema as w, ensureConversationWake as wt, scheduledRunId as x, countPendingConversationMessages as xt, saveScheduledAutomation as y, completeConversationStop as yt, collectEventAutomationMatchKeys as z, hasRunnableConversationWork$1 as zt };