@sentry/junior 0.251.0 → 0.253.0

package/dist/{tasks-DDzBxMio.js → tasks-DThIG7F-.js}

@@ -1,21 +1,21 @@
-import { d as unwrapCurrentInstruction, f as escapeXml, i as completeText, o as resolveGatewayModel } from "./client-DMt9kArs.js";
-import { d as logException, o as getActiveTraceId, p as logWarn, s as getLogContextAttributes, t as buildTurnFailureResponse, v as setSpanAttributes } from "./logging-BkI10z0D.js";
+import { d as unwrapCurrentInstruction, f as escapeXml, i as completeText, o as resolveGatewayModel } from "./client-CRVXpEWi.js";
+import { d as logException, o as getActiveTraceId, p as logWarn, s as getLogContextAttributes, t as buildTurnFailureResponse, v as setSpanAttributes } from "./logging-B0QxCh3D.js";
 import { n as captureMessage } from "./sentry-CgWZM_kV.js";
-import { n as botConfig, v as normalizeSlackEmojiName } from "./config-iEOq080E.js";
+import { n as botConfig, v as normalizeSlackEmojiName } from "./config-B7joRWt7.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-C8u1HAdN.js";
-import { a as juniorSchedulerRuns, o as juniorSchedulerTasks, s as juniorAutomationVersions, u as juniorEventAutomations } from "./executor-BeH9LDKI.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-CPxNfHWa.js";
+import { a as juniorAutomationVersions, o as juniorAutomationRuns, s as juniorAutomations } from "./executor-YL577nNt.js";
 import { d as contextProvenance, f as instructionActors, n as agentHistoryItemSchema, p as instructionProvenanceFor } from "./history-9pO1Zd4Y.js";
-import { p as credentialSubjectSchema } from "./registry-CN2Nie72.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-Ctw_jKaS.js";
+import { p as credentialSubjectSchema } from "./registry-BO2LM2oW.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-CvcbAtJH.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-AsD2uz0m.js";
-import { A as eventAutomationSchema, D as scheduledRunSchema, E as scheduledAutomationSchema, S as automationVersionSchema } from "./automation-gznOMaQ2.js";
+import { D as fenceLock, O as withLock, T as MUTATION_LOCK_TTL_MS, k as sleep, w as getStateAdapter } from "./profile-p1oiViVs.js";
+import { A as eventAutomationSchema, 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);
@@ -2854,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,
@@ -2881,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
@@ -2960,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,
+		const rows = await tx.update(juniorAutomations).set({
+			...columns,
 			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,
-			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;
 	});
 }
@@ -3061,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));
@@ -3100,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.
@@ -3112,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);
@@ -3123,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
@@ -3134,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.");
@@ -3148,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,
@@ -3169,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) {
@@ -3254,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) {
@@ -3311,28 +3240,17 @@ async function listScheduledAutomationsForTeam(db, teamId) {
 	return await readListedScheduledAutomations(db, teamId);
 }
 async function writeScheduledAutomation(db, task, current, editedBy) {
-	if (current?.status === "blocked" && task.status === "active" && typeof task.nextRunAtMs === "number" && Number.isFinite(task.nextRunAtMs)) await db.delete(juniorSchedulerRuns).where(and(eq(juniorSchedulerRuns.id, scheduledRunId(task.id, task.nextRunAtMs)), eq(juniorSchedulerRuns.status, "blocked")));
+	if (current?.status === "blocked" && task.status === "active" && typeof task.nextRunAtMs === "number" && Number.isFinite(task.nextRunAtMs)) await db.delete(juniorAutomationRuns).where(and(eq(juniorAutomationRuns.id, scheduledRunId(task.id, task.nextRunAtMs)), eq(juniorAutomationRuns.status, "blocked")));
 	if (task.status === "deleted" && current?.status !== "deleted") await skipPendingRunsForDeletedTask(db, task);
 	await upsertScheduledAutomation(db, task);
-	await recordAutomationVersion(db, "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.`;
-	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);
-		if (!parsed.success || parsed.data.status !== "pending") continue;
-		const next = scheduledRunSchema.parse({
-			...parsed.data,
-			completedAtMs: task.updatedAtMs,
-			errorMessage,
-			status: "skipped"
-		});
-		await db.update(juniorSchedulerRuns).set({
-			record: next,
-			status: next.status
-		}).where(and(eq(juniorSchedulerRuns.id, next.id), eq(juniorSchedulerRuns.status, "pending")));
-	}
+	await db.update(juniorAutomationRuns).set({
+		completedAtMs: task.updatedAtMs,
+		errorMessage: `Scheduled automation ${task.id} was deleted before the run started.`,
+		status: "skipped"
+	}).where(and(eq(juniorAutomationRuns.automationId, task.id), eq(juniorAutomationRuns.status, "pending")));
 }
 /** Create a scheduled automation once under its retry-stable task lock. */
 async function createScheduledAutomation(db, task) {

package/dist/{thread-state-BlD6loX7.js → thread-state-BQxkL7Xm.js}

@@ -1,10 +1,10 @@
-import { I as isRecord, L as toOptionalNumber, R as toOptionalString } from "./logging-BkI10z0D.js";
-import { d as getDb } from "./viewer-C8u1HAdN.js";
+import { I as isRecord, L as toOptionalNumber, R as toOptionalString } from "./logging-B0QxCh3D.js";
+import { d as getDb } from "./viewer-CPxNfHWa.js";
 import { d as juniorDestinations } from "./agent-invocations-D_YoNnAn.js";
-import { d as juniorLocationConfigurations } from "./executor-BeH9LDKI.js";
-import { Kt as persistConversationMessages } from "./tasks-DDzBxMio.js";
-import { it as JUNIOR_THREAD_STATE_TTL_MS } from "./agent-hooks-Ctw_jKaS.js";
-import { w as getStateAdapter } from "./profile-AsD2uz0m.js";
+import { l as juniorLocationConfigurations } from "./executor-YL577nNt.js";
+import { Kt as persistConversationMessages } from "./tasks-DThIG7F-.js";
+import { it as JUNIOR_THREAD_STATE_TTL_MS } from "./agent-hooks-CvcbAtJH.js";
+import { w as getStateAdapter } from "./profile-p1oiViVs.js";
 import { z } from "zod";
 import { randomUUID } from "node:crypto";
 import { and, eq, sql } from "drizzle-orm";

package/dist/{turn-failure-response-BRlfATgu.js → turn-failure-response-OAIxgzNh.js}

@@ -1,13 +1,13 @@
-import { _ as getProviderErrorUserMessage, g as getProviderErrorAttributes, h as findProviderError, p as ProviderError } from "./client-DMt9kArs.js";
-import { I as isRecord, t as buildTurnFailureResponse } from "./logging-BkI10z0D.js";
+import { _ as getProviderErrorUserMessage, g as getProviderErrorAttributes, h as findProviderError, p as ProviderError } from "./client-CRVXpEWi.js";
+import { I as isRecord, t as buildTurnFailureResponse } from "./logging-B0QxCh3D.js";
 import { g as parseSlackMessageTs } from "./actor-BTtLaeWy.js";
-import { c as getConversationEventStore, d as getDb } from "./viewer-C8u1HAdN.js";
-import { Gt as hydrateConversationMessages, an as markConversationMessage } from "./tasks-DDzBxMio.js";
-import { Nt as listConversationAnnotations } from "./agent-hooks-Ctw_jKaS.js";
+import { c as getConversationEventStore, d as getDb } from "./viewer-CPxNfHWa.js";
+import { Gt as hydrateConversationMessages, an as markConversationMessage } from "./tasks-DThIG7F-.js";
+import { Nt as listConversationAnnotations } from "./agent-hooks-CvcbAtJH.js";
 import { J as removedCardSchema, Y as resolveMessageCards, q as readMessageCardRefs } from "./conversation-T18Xlkx9.js";
-import { r as clearPendingAuth, u as buildDeterministicTurnId } from "./pending-auth-h0B3FQEo.js";
+import { r as clearPendingAuth, u as buildDeterministicTurnId } from "./pending-auth-CwA1uLA9.js";
 import { d as markTurnCompleted, u as markTurnClosed } from "./oauth-authorization-BA4Dt6a7.js";
-import { o as persistThreadStateById, r as getPersistedThreadState, s as coerceThreadConversationState } from "./thread-state-BlD6loX7.js";
+import { o as persistThreadStateById, r as getPersistedThreadState, s as coerceThreadConversationState } from "./thread-state-BQxkL7Xm.js";
 //#region src/chat/conversations/pending-cards.ts
 /** Select undelivered cards and load their latest saved facts. */
 async function loadPendingMessageCards(conversationId) {

package/dist/{turn-lifecycle-hMCbr_Ah.js → turn-lifecycle-BAEJpjDI.js}

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

package/dist/{turn-session-routing-DLb6eQMT.js → turn-session-routing-F5s728f0.js}

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

package/dist/{validation-C2lG6yVH.js → validation-DFM4-vDr.js}

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

package/dist/{version-CyJ_kMe8.js → version-B80CD9sN.js}

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

package/dist/version.js

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

package/dist/{viewer-C8u1HAdN.js → viewer-CPxNfHWa.js}

@@ -1,9 +1,9 @@
 import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.js";
-import { F as normalizeIdentityEmail } from "./logging-BkI10z0D.js";
-import { i as getChatConfig } from "./config-iEOq080E.js";
+import { F as normalizeIdentityEmail } from "./logging-B0QxCh3D.js";
+import { i as getChatConfig } from "./config-B7joRWt7.js";
 import { d as parseSlackTeamId, o as parseActorUserId, u as parseSlackChannelReferenceId } from "./actor-BTtLaeWy.js";
 import { c as juniorIdentities, d as juniorDestinations, l as juniorUsers, o as conversationReadColumns, s as juniorConversations } from "./agent-invocations-D_YoNnAn.js";
-import { _ as juniorConversationEvents, f as juniorConversationParticipants, g as juniorConversationMetrics, h as CONVERSATION_METRICS, p as juniorConversationBindings, t as createJuniorSqlExecutor, y as juniorConversationAnnotations } from "./executor-BeH9LDKI.js";
+import { _ as juniorConversationAnnotations, d as juniorConversationBindings, h as juniorConversationEvents, m as juniorConversationMetrics, p as CONVERSATION_METRICS, t as createJuniorSqlExecutor, u as juniorConversationParticipants } from "./executor-YL577nNt.js";
 import { c as newConversationEventSchema, h as usageSchema, l as encodeHistoryPayload, o as decodeStoredConversationEvent, r as conversationEventDataSchema, s as historyReplacementSchema } from "./history-9pO1Zd4Y.js";
 import { randomUUID } from "node:crypto";
 import { and, asc, desc, eq, gt, gte, inArray, isNull, lt, lte, ne, or, sql } from "drizzle-orm";