@sentry/junior 0.250.0 → 0.252.0

package/dist/{tasks-B8nH3ND_.js → tasks-DwGlFX9i.js}

@@ -1,21 +1,21 @@
-import { d as unwrapCurrentInstruction, f as escapeXml, i as completeText, o as resolveGatewayModel } from "./client-Q27hki0Y.js";
-import { d as logException, o as getActiveTraceId, p as logWarn, s as getLogContextAttributes, t as buildTurnFailureResponse, v as setSpanAttributes } from "./logging-C22RdmU8.js";
+import { d as unwrapCurrentInstruction, f as escapeXml, i as completeText, o as resolveGatewayModel } from "./client-ROZeVjq0.js";
+import { d as logException, o as getActiveTraceId, p as logWarn, s as getLogContextAttributes, t as buildTurnFailureResponse, v as setSpanAttributes } from "./logging-COUsTFIL.js";
 import { n as captureMessage } from "./sentry-CgWZM_kV.js";
-import { n as botConfig, v as normalizeSlackEmojiName } from "./config-Cb--Qs-g.js";
+import { n as botConfig, v as normalizeSlackEmojiName } from "./config-DNNkxfGS.js";
 import { c as toStoredSlackActor, f as parseSlackUserId, g as parseSlackMessageTs } from "./actor-BTtLaeWy.js";
-import { c as getConversationEventStore, f as getSqlExecutor, m as withConversationEventLock, p as createSqlConversationEventStore, u as getConversationStore, v as startLocationThread, x as addAgentTurnUsage, y as bindProviderConversation } from "./viewer-DdzigZQh.js";
-import { a as juniorSchedulerRuns, o as juniorSchedulerTasks, s as juniorAutomationVersions, u as juniorEventAutomations } from "./executor-D8y7v95s.js";
+import { c as getConversationEventStore, f as getSqlExecutor, m as withConversationEventLock, p as createSqlConversationEventStore, u as getConversationStore, v as startLocationThread, x as addAgentTurnUsage, y as bindProviderConversation } from "./viewer-D96vo_42.js";
+import { a as juniorSchedulerRuns, o as juniorAutomationVersions, s as juniorAutomations } from "./executor-_4bdoCxe.js";
 import { d as contextProvenance, f as instructionActors, n as agentHistoryItemSchema, p as instructionProvenanceFor } from "./history-9pO1Zd4Y.js";
-import { p as credentialSubjectSchema } from "./registry-BvsLuoLK.js";
-import { Kt as withSlackRetries, Lt as SlackActionError, Qt as authenticationUnlinkedEvent, Vt as getSlackClient, Wt as normalizeSlackConversationId, Xt as agentsInstructionsUpdatedEvent, Yt as JUNIOR_NATIVE_EVENT_NAMESPACE, Zt as authenticationLinkedEvent, n as applyPluginFormatMarkdown } from "./agent-hooks-CtZuJPTU.js";
-import { G as messageCardRef } from "./conversation-NutPJ8S8.js";
-import { D as fenceLock, O as withLock, T as MUTATION_LOCK_TTL_MS, k as sleep, w as getStateAdapter } from "./profile-DK9umvav.js";
+import { p as credentialSubjectSchema } from "./registry-CeEpPna6.js";
+import { $t as authenticationUnlinkedEvent, Gt as normalizeSlackConversationId, Ht as getSlackClient, Qt as authenticationLinkedEvent, Rt as SlackActionError, Xt as JUNIOR_NATIVE_EVENT_NAMESPACE, Zt as agentsInstructionsUpdatedEvent, n as applyPluginFormatMarkdown, qt as withSlackRetries } from "./agent-hooks-DcoKnnxn.js";
+import { G as messageCardRef } from "./conversation-T18Xlkx9.js";
+import { D as fenceLock, O as withLock, T as MUTATION_LOCK_TTL_MS, k as sleep, w as getStateAdapter } from "./profile-DP4LKL6V.js";
 import { A as eventAutomationSchema, D as scheduledRunSchema, E as scheduledAutomationSchema, S as automationVersionSchema } from "./automation-gznOMaQ2.js";
 import { isDeepStrictEqual } from "node:util";
 import { z } from "zod";
 import { createHash } from "node:crypto";
-import { and, asc, desc, eq, inArray, ne, notInArray, or, sql } from "drizzle-orm";
-import { actorSchema, eventMatches, slackDestinationSchema, sourceSchema, taskOutcomeSchema } from "@sentry/junior-plugin-api";
+import { and, asc, desc, eq, inArray, ne, or, sql } from "drizzle-orm";
+import { actorSchema, eventMatches, sourceSchema } from "@sentry/junior-plugin-api";
 //#region src/chat/pi/messages.ts
 /** Permissive schema for durable Pi SDK messages whose content shape may evolve. */
 const piMessageSchema = z.object({ role: z.string() }).passthrough().transform((value) => value);
@@ -444,12 +444,27 @@ function isHumanConversationMessage(message) {
 function getConversationMessageSlackTs(message) {
 	return parseSlackMessageTs(message.meta?.slackTs);
 }
+const SOURCE_TEXT_MAX_LENGTH = {
+	conversation: 500,
+	run: 2e3,
+	task: 500
+};
+const SOURCE_LABELS = {
+	conversation: "First user message",
+	run: "Task input",
+	task: "Task instruction"
+};
 const TITLE_PROMPTS = {
 	conversation: [
 		"Generate a concise 5-8 word conversation title from the first user message below.",
 		"Capture the user's main request.",
 		"Reply with ONLY the title, with no quotes or trailing punctuation."
 	],
+	run: [
+		"Generate a concise 5-8 word title for one task run from its task input below.",
+		"Capture what this run is about. Prefer the specific event or subject over the task wording.",
+		"Reply with ONLY the title, with no quotes or trailing punctuation."
+	],
 	task: [
 		"Generate a concise 5-8 word task title from the task instruction below.",
 		"Capture the task's main purpose.",
@@ -483,7 +498,7 @@ async function generateShortTitle(args) {
 				content: [
 					...TITLE_PROMPTS[args.kind],
 					"",
-					args.kind === "conversation" ? `First user message: ${sourceText.slice(0, 500)}` : `Task instruction: ${sourceText.slice(0, 500)}`
+					`${SOURCE_LABELS[args.kind]}: ${sourceText.slice(0, SOURCE_TEXT_MAX_LENGTH[args.kind])}`
 				].join("\n"),
 				timestamp: Date.now()
 			}],
@@ -518,9 +533,10 @@ const inFlightTitles = /* @__PURE__ */ new Map();
 * Set-once conversation title from the earliest human message.
 *
 * One automatic generation path for every surface. Starts only from durable
-* transcript writes via `scheduleConversationTitle`. Returns a newly persisted
-* title, or undefined when the conversation is already titled or generation
-* does not apply.
+* transcript writes via `scheduleConversationTitle`. A dispatched run, such as
+* an automation run, has no human message, so its title comes from the run
+* input. Returns a newly persisted title, or undefined when the conversation
+* is already titled or generation does not apply.
 */
 async function ensureConversationTitle(args) {
 	const pending = inFlightTitles.get(args.conversationId);
@@ -531,28 +547,37 @@ async function ensureConversationTitle(args) {
 	inFlightTitles.set(args.conversationId, work);
 	return work;
 }
+/** Return the earliest user message, which is the input of a dispatched run. */
+function getRunInputMessage(conversation) {
+	let earliest;
+	for (const message of conversation.messages) if (message.role === "user" && (!earliest || message.createdAtMs < earliest.createdAtMs)) earliest = message;
+	return earliest;
+}
 async function ensureConversationTitleOnce(args) {
-	if (!args.conversation.messages.some(isHumanConversationMessage)) return;
+	const humanMessage = getThreadTitleSourceMessage(args.conversation);
+	const runInputMessage = humanMessage ? void 0 : getRunInputMessage(args.conversation);
+	if (!humanMessage && !runInputMessage) return;
 	const store = args.conversationStore ?? getConversationStore();
 	try {
 		const stored = await store.get({ conversationId: args.conversationId });
 		if (stored?.title?.trim()) return;
 		if (stored?.parentConversationId) return;
-		const titleSourceMessage = getThreadTitleSourceMessage(args.conversation);
+		const titleSourceMessage = humanMessage ?? (stored?.source === "plugin" ? runInputMessage : void 0);
 		const sourceText = titleSourceMessage?.text.trim() ?? "";
 		if (!titleSourceMessage || !sourceText) return;
+		const kind = humanMessage ? "conversation" : "run";
 		let title;
 		try {
 			title = await generateShortTitle({
 				completeText,
-				kind: "conversation",
+				kind,
 				sourceText
-			}) ?? fallbackShortTitle(sourceText, "Conversation");
+			});
 		} catch (error) {
 			logWarn("conversation.title.generation.failed", { "exception.message": error instanceof Error ? error.message : String(error) });
-			title = fallbackShortTitle(sourceText, "Conversation");
 		}
-		const normalized = title.trim();
+		if (!title && kind === "conversation") title = fallbackShortTitle(sourceText, "Conversation");
+		const normalized = title?.trim();
 		if (!normalized) return;
 		const activityAtMs = titleSourceMessage.createdAtMs;
 		const nowMs = args.nowMs ?? Date.now();
@@ -574,7 +599,7 @@ async function ensureConversationTitleOnce(args) {
 	}
 }
 /**
-* Start title work after durable human transcript writes. This is the only
+* Start title work after durable transcript writes. This is the only
 * entry that starts generation; `settleConversationTitleWork` joins it.
 */
 function scheduleConversationTitle(args) {
@@ -2829,26 +2854,31 @@ function sameDefinitionValue(left, right) {
 * transaction and lock as the Automation write. Without `current`, the
 * Automation is new, so the creator saves version 1.
 */
-async function recordAutomationVersion(db, kind, task, current, editedBy) {
+async function recordAutomationVersion(db, task, current, editedBy) {
 	const definition = automationDefinition(task);
 	if (current && sameDefinitionValue(automationDefinition(current), definition)) return;
 	await db.insert(juniorAutomationVersions).values({
-		kind,
 		automationId: task.id,
 		version: sql`(
       SELECT coalesce(max(${juniorAutomationVersions.version}), 0) + 1
       FROM ${juniorAutomationVersions}
-      WHERE ${juniorAutomationVersions.kind} = ${kind}
-        AND ${juniorAutomationVersions.automationId} = ${task.id}
+      WHERE ${juniorAutomationVersions.automationId} = ${task.id}
     )`,
 		createdAtMs: Date.now(),
 		editedBy: editedBy ?? (current ? null : task.createdBy),
 		definition
 	});
 }
-function parseVersionRow(kind, row) {
+const versionColumns = {
+	createdAtMs: juniorAutomationVersions.createdAtMs,
+	definition: juniorAutomationVersions.definition,
+	editedBy: juniorAutomationVersions.editedBy,
+	kind: juniorAutomations.kind,
+	version: juniorAutomationVersions.version
+};
+function parseVersionRow(row) {
 	return automationVersionSchema.parse({
-		kind,
+		kind: row.kind,
 		version: row.version,
 		createdAt: new Date(row.createdAtMs).toISOString(),
 		editedBy: row.editedBy,
@@ -2856,13 +2886,13 @@ function parseVersionRow(kind, row) {
 	});
 }
 /** Read one saved definition. */
-async function readAutomationVersion(db, kind, automationId, version) {
-	const [row] = await db.select().from(juniorAutomationVersions).where(and(eq(juniorAutomationVersions.kind, kind), eq(juniorAutomationVersions.automationId, automationId), eq(juniorAutomationVersions.version, version))).limit(1);
-	return row ? parseVersionRow(kind, row) : void 0;
+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, kind, automationId, limit) {
-	return (await db.select().from(juniorAutomationVersions).where(and(eq(juniorAutomationVersions.kind, kind), eq(juniorAutomationVersions.automationId, automationId))).orderBy(desc(juniorAutomationVersions.version)).limit(limit)).map((row) => parseVersionRow(kind, row));
+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);
 }
 //#endregion
 //#region src/chat/event-automations/run-limit.ts
@@ -2935,99 +2965,78 @@ async function clearEventAutomationRuns(automationId, state = getStateAdapter())
 }
 //#endregion
 //#region src/chat/event-automations/store.ts
-const retainedEventAutomationSchema = eventAutomationSchema.extend({
-	destination: slackDestinationSchema,
-	outcomes: z.array(taskOutcomeSchema).max(5)
-});
-const eventAutomationRowColumns = {
-	status: juniorEventAutomations.status,
-	statusReason: juniorEventAutomations.statusReason,
-	task: juniorEventAutomations.task,
-	title: juniorEventAutomations.title
-};
-/** JSON task payload must not carry SQL-backed columns. */
-function eventAutomationJsonPayload(task) {
-	const { status: _status, statusReason: _statusReason, title: _title, ...payload } = task;
-	return payload;
+/**
+* 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, id: _id, ...record } = eventAutomationSchema.parse(definition);
+	return {
+		channelId: record.destination.channelId,
+		creatorSlackUserId: record.createdBy.slackUserId,
+		identifier: record.trigger.identifier,
+		instruction: record.task.text,
+		namespace: record.trigger.namespace,
+		record,
+		teamId: record.destination.teamId,
+		title: title?.trim() || null
+	};
 }
-/** Decode a retained event Automation with its SQL-backed fields. */
+/** Decode an event Automation row with its SQL-backed fields. */
 function parseEventAutomationRow(row) {
-	const raw = row.task && typeof row.task === "object" ? { ...row.task } : row.task;
-	if (raw && typeof raw === "object" && "title" in raw) delete raw.title;
-	if (raw && typeof raw === "object" && !("outcomes" in raw) && "destination" in raw) raw.outcomes = [{
-		action: "send_message",
-		destination: raw.destination
-	}];
-	const retained = retainedEventAutomationSchema.parse(raw);
-	const { threadTs: _threadTs, ...destination } = retained.destination;
+	const task = eventAutomationSchema.parse({
+		...row.record,
+		createdAtMs: row.createdAtMs,
+		id: row.id
+	});
 	const title = row.title?.trim();
 	return {
-		...retained,
-		destination,
-		outcomes: retained.outcomes.map((outcome) => {
-			const { threadTs: _threadTs, ...destination } = outcome.destination;
-			return {
-				...outcome,
-				destination
-			};
-		}),
-		status: row.status ?? "active",
+		...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 ne(juniorEventAutomations.status, "deleted");
+	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({ ...eventAutomationRowColumns }).from(juniorEventAutomations).where(eq(juniorEventAutomations.id, id)).limit(1);
+	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 parsed = eventAutomationSchema.parse(eventAutomationJsonPayload(task));
-	const title = task.title?.trim() || null;
-	if ((await getEventAutomation(db, parsed.id))?.status === "deleted") await clearEventAutomationRuns(parsed.id);
+	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(juniorEventAutomations).values({
-			id: parsed.id,
-			teamId: parsed.destination.teamId,
-			namespace: parsed.trigger.namespace,
-			identifier: parsed.trigger.identifier,
-			createdAtMs: parsed.createdAtMs,
-			status: "active",
-			title,
-			task: parsed
-		}).onConflictDoNothing().returning({ ...eventAutomationRowColumns });
+		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, "event", created, void 0);
+			await recordAutomationVersion(tx, created, void 0);
 			return created;
 		}
-		const existing = await getEventAutomation(tx, parsed.id);
-		if (!existing) return {
-			...parsed,
-			status: "active",
-			...title ? { title } : void 0
-		};
+		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(juniorEventAutomations).set({
-			teamId: parsed.destination.teamId,
-			namespace: parsed.trigger.namespace,
-			identifier: parsed.trigger.identifier,
-			status: "active",
-			statusReason: null,
-			title,
-			task: parsed
-		}).where(and(eq(juniorEventAutomations.id, parsed.id), eq(juniorEventAutomations.status, "deleted"))).returning({ ...eventAutomationRowColumns });
-		if (!rows[0]) return await getEventAutomation(tx, parsed.id) ?? {
-			...parsed,
+		const rows = await tx.update(juniorAutomations).set({
+			...columns,
 			status: "active",
-			...title ? { title } : void 0
-		};
+			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, "event", revived, void 0);
+		await recordAutomationVersion(tx, revived, void 0);
 		return revived;
 	});
 }
@@ -3036,31 +3045,25 @@ async function createEventAutomation(db, task) {
 * Pass `editedBy` when a person changes the definition so its version names them.
 */
 async function saveEventAutomation(db, task, expectedRevision, editedBy) {
-	const parsed = eventAutomationSchema.parse(eventAutomationJsonPayload(task));
-	const title = task.title?.trim() || null;
+	const columns = eventAutomationColumns(task);
 	return db.transaction(async (tx) => {
-		const rows = await tx.select({ ...eventAutomationRowColumns }).from(juniorEventAutomations).where(eq(juniorEventAutomations.id, parsed.id)).for("update");
+		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(juniorEventAutomations).set({
-			namespace: parsed.trigger.namespace,
-			identifier: parsed.trigger.identifier,
-			title,
-			task: parsed
-		}).where(eq(juniorEventAutomations.id, parsed.id)).returning({ ...eventAutomationRowColumns }))[0]);
-		await recordAutomationVersion(tx, "event", saved, current, editedBy);
+		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(juniorEventAutomations).set({ status: "deleted" }).where(and(eq(juniorEventAutomations.id, id), activeEventAutomationWhere())).returning({ ...eventAutomationRowColumns });
+	const rows = await db.update(juniorAutomations).set({ status: "deleted" }).where(and(eq(juniorAutomations.id, id), activeEventAutomationWhere())).returning();
 	return rows[0] ? parseEventAutomationRow(rows[0]) : void 0;
 }
 /** List live event automations in one Slack workspace. */
 async function listEventAutomationsForTeam(db, teamId) {
-	return (await db.select({ ...eventAutomationRowColumns }).from(juniorEventAutomations).where(and(eq(juniorEventAutomations.teamId, teamId), activeEventAutomationWhere())).orderBy(asc(juniorEventAutomations.createdAtMs), asc(juniorEventAutomations.id))).map(parseEventAutomationRow);
+	return (await db.select().from(juniorAutomations).where(and(eq(juniorAutomations.teamId, teamId), activeEventAutomationWhere())).orderBy(asc(juniorAutomations.createdAtMs), asc(juniorAutomations.id))).map(parseEventAutomationRow);
 }
 function viewerSlackIdentities(user) {
 	return user.identities.filter((identity) => identity.provider === "slack" && Boolean(identity.providerTenantId) && Boolean(identity.providerSubjectId));
@@ -3075,9 +3078,9 @@ function eventAutomationBelongsToUser(task, user) {
 */
 async function listDeletedEventAutomationsCreatedBy(db, user, limit) {
 	const identities = viewerSlackIdentities(user);
-	const ownership = or(...identities.map((identity) => and(eq(juniorEventAutomations.teamId, identity.providerTenantId), sql`${juniorEventAutomations.task}->'createdBy'->>'slackUserId' = ${identity.providerSubjectId}`)));
+	const ownership = or(...identities.map((identity) => and(eq(juniorAutomations.teamId, identity.providerTenantId), eq(juniorAutomations.creatorSlackUserId, identity.providerSubjectId))));
 	if (!ownership) return [];
-	return (await db.select({ ...eventAutomationRowColumns }).from(juniorEventAutomations).where(and(ownership, eq(juniorEventAutomations.status, "deleted"))).orderBy(desc(juniorEventAutomations.createdAtMs), desc(juniorEventAutomations.id)).limit(limit)).map(parseEventAutomationRow);
+	return (await db.select().from(juniorAutomations).where(and(ownership, eq(juniorAutomations.kind, "event"), eq(juniorAutomations.status, "deleted"))).orderBy(desc(juniorAutomations.createdAtMs), desc(juniorAutomations.id)).limit(limit)).map(parseEventAutomationRow);
 }
 /**
 * Collect match keys from live event automations for these identifiers and event types.
@@ -3087,7 +3090,7 @@ 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({ ...eventAutomationRowColumns }).from(juniorEventAutomations).where(and(eq(juniorEventAutomations.teamId, input.teamId), eq(juniorEventAutomations.namespace, input.namespace), inArray(juniorEventAutomations.identifier, identifiers), eq(juniorEventAutomations.status, "active"))).orderBy(asc(juniorEventAutomations.createdAtMs), asc(juniorEventAutomations.id));
+	const rows = await db.select().from(juniorAutomations).where(and(eq(juniorAutomations.kind, "event"), eq(juniorAutomations.teamId, input.teamId), eq(juniorAutomations.namespace, input.namespace), inArray(juniorAutomations.identifier, identifiers), eq(juniorAutomations.status, "active"))).orderBy(asc(juniorAutomations.createdAtMs), asc(juniorAutomations.id));
 	const keys = /* @__PURE__ */ new Set();
 	for (const row of rows) {
 		const task = parseEventAutomationRow(row);
@@ -3098,7 +3101,7 @@ async function collectEventAutomationMatchKeys(db, input) {
 }
 /** Find every live task matching one normalized event. */
 async function findMatchingEventAutomations(db, event, teamId) {
-	return (await db.select({ ...eventAutomationRowColumns }).from(juniorEventAutomations).where(and(eq(juniorEventAutomations.teamId, teamId), eq(juniorEventAutomations.namespace, event.namespace), eq(juniorEventAutomations.identifier, event.identifier), eq(juniorEventAutomations.status, "active"))).orderBy(asc(juniorEventAutomations.createdAtMs), asc(juniorEventAutomations.id))).map(parseEventAutomationRow).filter((task) => task.trigger.events.includes(event.eventType) && eventMatches(task.trigger.match, event.data));
+	return (await db.select().from(juniorAutomations).where(and(eq(juniorAutomations.kind, "event"), eq(juniorAutomations.teamId, teamId), eq(juniorAutomations.namespace, event.namespace), eq(juniorAutomations.identifier, event.identifier), eq(juniorAutomations.status, "active"))).orderBy(asc(juniorAutomations.createdAtMs), asc(juniorAutomations.id))).map(parseEventAutomationRow).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
@@ -3109,7 +3112,7 @@ async function findMatchingEventAutomations(db, event, teamId) {
 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(juniorEventAutomations).where(eq(juniorEventAutomations.id, id)).for("update");
+		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.");
@@ -3123,10 +3126,10 @@ async function setEventAutomationStatus(db, id, status, revision) {
 			status,
 			statusReason: void 0
 		};
-		await tx.update(juniorEventAutomations).set({
+		await tx.update(juniorAutomations).set({
 			status: next.status,
 			statusReason: next.statusReason ?? null
-		}).where(eq(juniorEventAutomations.id, id));
+		}).where(eventAutomationWhere(id));
 		const { statusReason: _statusReason, ...rest } = current;
 		return {
 			...rest,
@@ -3144,65 +3147,31 @@ async function setEventAutomationStatus(db, id, status, revision) {
 * an automation that the dashboard shows as paused.
 */
 async function blockEventAutomation(db, id, reason) {
-	return (await db.update(juniorEventAutomations).set({
-		status: sql`case when ${juniorEventAutomations.status} = 'active' then 'blocked' else ${juniorEventAutomations.status} end`,
+	return (await db.update(juniorAutomations).set({
+		status: sql`case when ${juniorAutomations.status} = 'active' then 'blocked' else ${juniorAutomations.status} end`,
 		statusReason: reason
-	}).where(and(eq(juniorEventAutomations.id, id), or(eq(juniorEventAutomations.status, "active"), and(eq(juniorEventAutomations.status, "paused"), sql`${juniorEventAutomations.statusReason} is distinct from ${reason}`)))).returning({ status: juniorEventAutomations.status }))[0]?.status === "blocked";
+	}).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";
 }
 //#endregion
 //#region src/chat/scheduled-automations/tasks.ts
 const SCHEDULER_KEY_PREFIX = "junior:scheduler";
-const retainedScheduledAutomationSchema = scheduledAutomationSchema.omit({
-	creatorIdentityId: true,
-	title: true
-}).extend({
-	destination: slackDestinationSchema,
-	outcomes: z.array(taskOutcomeSchema).max(5),
-	version: z.number().optional()
-}).strict();
-/** Decode a retained scheduler task row and reject invalid routing context. */
+/** Decode a Scheduled automation row. Returns undefined for an invalid 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 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, ...retainedTask } = parsed.data;
-	const destination = {
-		platform: "slack",
-		teamId: retainedTask.destination.teamId,
-		channelId: retainedTask.destination.channelId
-	};
-	const task = {
-		...retainedTask,
-		destination,
-		outcomes: retainedTask.outcomes.map((outcome) => ({
-			...outcome,
-			destination: {
-				platform: "slack",
-				teamId: outcome.destination.teamId,
-				channelId: outcome.destination.channelId
-			}
-		}))
-	};
-	const fallbackIdentity = row.creatorIdentityId === null ? z.string().safeParse(legacyCreatorIdentityId) : void 0;
-	const creatorIdentityId = row.creatorIdentityId ?? (fallbackIdentity?.success ? fallbackIdentity.data : void 0);
-	if (creatorIdentityId === void 0) return void 0;
-	const fallbackTitle = row.title === null ? z.string().safeParse(legacyTitle) : void 0;
-	const title = (row.title !== null ? row.title : fallbackTitle?.success ? fallbackTitle.data : void 0)?.trim() || void 0;
-	return {
-		...task,
-		creatorIdentityId,
-		status,
-		...title ? { title } : void 0
+	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) {
@@ -3229,53 +3198,38 @@ function requireStoredTask(task) {
 		...normalizedTitle ? { title: normalizedTitle } : void 0
 	};
 }
-function scheduledAutomationJsonRecord(task) {
-	const { title: _title, ...record } = task;
-	return record;
-}
 async function upsertScheduledAutomation(db, task) {
-	const title = task.title?.trim() || null;
-	await db.insert(juniorSchedulerTasks).values({
-		createdAtMs: task.createdAtMs,
-		creatorIdentityId: task.creatorIdentityId,
-		creatorSlackUserId: task.createdBy.slackUserId,
-		id: task.id,
-		nextRunAtMs: task.nextRunAtMs,
-		record: scheduledAutomationJsonRecord(task),
-		runNowAtMs: task.runNowAtMs,
-		status: task.status,
-		teamId: task.destination.teamId,
-		title
+	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: juniorSchedulerTasks.id,
-		set: {
-			createdAtMs: sql`excluded.created_at_ms`,
-			creatorIdentityId: sql`excluded.creator_identity_id`,
-			creatorSlackUserId: sql`excluded.creator_slack_user_id`,
-			nextRunAtMs: sql`excluded.next_run_at_ms`,
-			record: sql`excluded.record`,
-			runNowAtMs: sql`excluded.run_now_at_ms`,
-			status: sql`excluded.status`,
-			teamId: sql`excluded.team_id`,
-			title: sql`excluded.title`
-		}
+		target: juniorAutomations.id,
+		set: columns
 	});
 }
 /** 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);
+	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({
-		creatorIdentityId: juniorSchedulerTasks.creatorIdentityId,
-		record: juniorSchedulerTasks.record,
-		title: juniorSchedulerTasks.title
-	}).from(juniorSchedulerTasks).where(and(notInArray(juniorSchedulerTasks.status, ["deleted"]), teamId === void 0 ? void 0 : eq(juniorSchedulerTasks.teamId, teamId))).orderBy(asc(juniorSchedulerTasks.createdAtMs), asc(juniorSchedulerTasks.id))).map(parseScheduledAutomationRow).filter(isListedScheduledAutomation);
+	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 in stable creation order. */
 async function listScheduledAutomations(db) {
@@ -3289,7 +3243,7 @@ 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(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 upsertScheduledAutomation(db, task);
-	await recordAutomationVersion(db, "scheduled", task, current, editedBy);
+	await recordAutomationVersion(db, task, current, editedBy);
 }
 async function skipPendingRunsForDeletedTask(db, task) {
 	const errorMessage = `Scheduled automation ${task.id} was deleted before the run started.`;

package/dist/{thread-state-BTOLzCM-.js → thread-state-Ces6tXmB.js}

@@ -1,10 +1,10 @@
-import { I as isRecord, L as toOptionalNumber, R as toOptionalString } from "./logging-C22RdmU8.js";
-import { d as getDb } from "./viewer-DdzigZQh.js";
+import { I as isRecord, L as toOptionalNumber, R as toOptionalString } from "./logging-COUsTFIL.js";
+import { d as getDb } from "./viewer-D96vo_42.js";
 import { d as juniorDestinations } from "./agent-invocations-D_YoNnAn.js";
-import { d as juniorLocationConfigurations } from "./executor-D8y7v95s.js";
-import { Kt as persistConversationMessages } from "./tasks-B8nH3ND_.js";
-import { rt as JUNIOR_THREAD_STATE_TTL_MS } from "./agent-hooks-CtZuJPTU.js";
-import { w as getStateAdapter } from "./profile-DK9umvav.js";
+import { u as juniorLocationConfigurations } from "./executor-_4bdoCxe.js";
+import { Kt as persistConversationMessages } from "./tasks-DwGlFX9i.js";
+import { it as JUNIOR_THREAD_STATE_TTL_MS } from "./agent-hooks-DcoKnnxn.js";
+import { w as getStateAdapter } from "./profile-DP4LKL6V.js";
 import { z } from "zod";
 import { randomUUID } from "node:crypto";
 import { and, eq, sql } from "drizzle-orm";