@sentry/junior 0.240.0 → 0.242.0

package/dist/{checkpoint-C1ZnSz7r.js → tasks-EqCtmUJ2.js}

@@ -1,17 +1,21 @@
-import { d as unwrapCurrentInstruction, f as escapeXml, i as completeText, o as resolveGatewayModel } from "./client-Cn73E7br.js";
-import { d as logException, o as getActiveTraceId, p as logWarn, t as buildTurnFailureResponse, v as setSpanAttributes } from "./logging-BSNF167N.js";
-import { n as botConfig } from "./config-B0S86yw9.js";
-import { c as toStoredSlackActor, 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-XE3nFqKM.js";
+import { d as unwrapCurrentInstruction, f as escapeXml, i as completeText, o as resolveGatewayModel } from "./client-D51G-Jdg.js";
+import { d as logException, o as getActiveTraceId, p as logWarn, s as getLogContextAttributes, t as buildTurnFailureResponse, v as setSpanAttributes } from "./logging-BdZ_mK3q.js";
+import { n as captureMessage } from "./sentry-CgWZM_kV.js";
+import { n as botConfig, v as normalizeSlackEmojiName } from "./config-C6Uu3Re9.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-BOgEy5zC.js";
+import { a as juniorSchedulerRuns, o as juniorSchedulerTasks, s as juniorAutomationVersions, u as juniorEventAutomations } from "./executor-CGUukwus.js";
 import { d as instructionActors, f as instructionProvenanceFor, n as agentHistoryItemSchema, u as contextProvenance } from "./history-BLTUgFYO.js";
-import { p as credentialSubjectSchema } from "./registry-DLZlAhdP.js";
-import { Jt as agentsInstructionsUpdatedEvent, Xt as authenticationUnlinkedEvent, Yt as authenticationLinkedEvent, qt as JUNIOR_NATIVE_EVENT_NAMESPACE } from "./agent-hooks-JFbgedMZ.js";
+import { p as credentialSubjectSchema } from "./registry-XJkXDNK2.js";
+import { Ft as SlackActionError, Ht as normalizeSlackConversationId, Jt as agentsInstructionsUpdatedEvent, Wt as withSlackRetries, Xt as authenticationUnlinkedEvent, Yt as authenticationLinkedEvent, n as applyPluginFormatMarkdown, qt as JUNIOR_NATIVE_EVENT_NAMESPACE, zt as getSlackClient } from "./agent-hooks-BVttjZvb.js";
 import { H as messageCardRef } from "./conversation-DwD-vquD.js";
-import { D as fenceLock, O as withLock, T as MUTATION_LOCK_TTL_MS, k as sleep, w as getStateAdapter } from "./profile-3t9H_IwL.js";
+import { D as fenceLock, O as withLock, T as MUTATION_LOCK_TTL_MS, k as sleep, w as getStateAdapter } from "./profile-2gPzzMib.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 { actorSchema, sourceSchema } from "@sentry/junior-plugin-api";
+import { and, asc, desc, eq, inArray, ne, notInArray, or, sql } from "drizzle-orm";
+import { actorSchema, eventMatches, slackDestinationSchema, sourceSchema, taskOutcomeSchema } 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);
@@ -711,13 +715,13 @@ function toStoredConversationMessage(message) {
 		createdAtMs: message.createdAtMs
 	};
 }
-function canonicalJson(value) {
-	if (Array.isArray(value)) return value.map(canonicalJson);
+function canonicalJson$1(value) {
+	if (Array.isArray(value)) return value.map(canonicalJson$1);
 	if (!value || typeof value !== "object") return value;
-	return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalJson(item)]));
+	return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalJson$1(item)]));
 }
 function messageStateKey(message) {
-	return createHash("sha256").update(JSON.stringify(canonicalJson(message))).digest("hex").slice(0, 32);
+	return createHash("sha256").update(JSON.stringify(canonicalJson$1(message))).digest("hex").slice(0, 32);
 }
 /** Hydrate the current message working set from canonical conversation events. */
 async function hydrateConversationMessages(args) {
@@ -1241,6 +1245,15 @@ async function recordGuardianActionReviewed(args) {
 	}]);
 }
 //#endregion
+//#region src/chat/tools/execution/tool-input-error.ts
+/** Thrown when a tool fails due to invalid model/user input, not a system error. */
+var ToolInputError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "ToolInputError";
+	}
+};
+//#endregion
 //#region src/chat/turn-context-tag.ts
 /**
 * Canonical tag name for the runtime turn context block injected into Pi
@@ -2159,4 +2172,1033 @@ async function saveDone(args) {
 	});
 }
 //#endregion
-export { resolveConversationTitle as $, commitAcceptedReply as A, recordAuthenticationLinked as B, isToolResultError as C, stripRuntimeTurnContext as D, retainRuntimeTurnContext as E, loadTurnProjection as F, recordSubscribedReplyRoute as G, recordAuthorizationRequested as H, loadTurnRoute as I, appendConversationMessages as J, recordToolExecutionStarted as K, openConversationProjection as L, loadConnectedMcpProviders as M, loadConversationProjection as N, trimTrailingAssistantMessages as O, loadProjection as P, persistConversationMessageSummaries as Q, recordAgentsInstructionsUpdated as R, isContinuablePiBoundary as S, normalizeToolNameFromResult as T, recordGuardianActionReviewed as U, recordAuthorizationCompleted as V, recordMcpProviderConnected as W, persistConversationMessages as X, hydrateConversationMessages as Y, projectConversationMessages as Z, getTerminalAssistantMessages as _, historyItemFromPiMessage as _t, completeTurnRecord as a, createConversationMemoryService as at, instructionTextForProjection as b, listTurnSummaries as c, isHumanConversationMessage as ct, TurnSliceLimitExceededError as d, recordDeliveredAssistantMessage as dt, settleConversationTitleWork as et, assertTurnToolCallLimit as f, turnHasReply as ft, getPiMessageRole as g, getAgentContextInputLimitTokens as gt, extractAssistantText as h, getAgentContextCompactionTriggerTokens as ht, abandonTurnRecord as i, buildConversationContext as it, commitMessages as j, TURN_CONTEXT_TAG as k, recordTurnSummary as l, markConversationMessage as lt, isTurnExecutionLimitExceededError as m, estimateTextTokens as mt, loadTurnCheckpoint as n, resolveTaskTitle as nt, failTurnRecord as o, estimateConversationContextTokens as ot, buildTurnErrorResponse as p, upsertConversationMessage as pt, recordTurnRoute as q, saveTurnCheckpoint as r, appendThreadContextMessages as rt, getTurnRecord as s, getConversationMessageSlackTs as st, continuableMessages as t, fallbackShortTitle as tt, persistWithRetry as u, normalizeConversationText as ut, getUserMessageInstructionText as v, piMessageFromHistoryItem as vt, isToolResultMessage as w, isAssistantMessage as x, hasRuntimeTurnContext as y, recordAttachmentsDelivered as z };
+//#region src/chat/slack/post-warning.ts
+const codes = /* @__PURE__ */ new Set([
+	"invalid_metadata_format",
+	"invalid_metadata_schema",
+	"metadata_too_large",
+	"invalid_arguments",
+	"invalid_blocks",
+	"missing_scope",
+	"missing_charset",
+	"superfluous_charset",
+	"message_truncated"
+]);
+const pathFields = /* @__PURE__ */ new Set([
+	"metadata",
+	"event_type",
+	"event_payload",
+	"entities",
+	"entity_type",
+	"entity_payload",
+	"external_ref",
+	"id",
+	"type",
+	"url",
+	"attributes",
+	"title",
+	"text",
+	"display_id",
+	"display_type",
+	"product_name",
+	"fields",
+	"status",
+	"custom_fields",
+	"key",
+	"label",
+	"value",
+	"long",
+	"format",
+	"link",
+	"display_order",
+	"app_unfurl_url",
+	"app_id",
+	"created_by",
+	"created_at",
+	"updated_by",
+	"updated_at",
+	"full_size_preview",
+	"preview_url",
+	"mime_type"
+]);
+const diagnosticWords = new Set(`WARN ERROR Message message metadata was incorrectly formatted The the will be
+  ignored as a result For for event entity refer to following errors error
+  missing required field fields property properties additional unexpected unknown
+  unsupported invalid expected received actual type types must should match matches
+  matching does not is are has have of at in on and or an only allowed allow
+  value values string number integer boolean object array null minimum maximum
+  length min max items item empty nonempty too long short large small size limit
+  exceeded exceeds less greater than equal valid format schema validation failed
+  failure cannot contain contains found one any all none enum pattern definition
+  defined constraint constraints satisfy satisfies with without provided specified
+  unrecognized unrecognised recognized recognised extraneous disallowed duplicate
+  unique malformed nested root exactly needs need requires requirement supported
+  json-pointer input different schema_uri schema_id schemas additionalProperties
+  minLength maxLength minItems maxItems anyOf oneOf allOf`.split(/\s+/));
+function summarizeDiagnostic(value) {
+	return value.slice(0, 2e3).replace(/\b(?:https?:\/\/|www\.)[^\s"'`<>]+/gi, "[value]").replace(/\/[^\s"'`[\],;()]*|[\p{L}\p{N}\p{M}_]+(?:[-./:@=+%~][\p{L}\p{N}\p{M}_]+)*|[^\s\w[\]{}():,;."'`/*=<>!?+-]/gu, (token) => {
+		if (token.startsWith("/")) return token.split("/").slice(0, 17).map((part, index) => index === 0 ? "" : pathFields.has(part) ? part : "*").join("/");
+		return codes.has(token) || pathFields.has(token) || diagnosticWords.has(token) ? token : "[value]";
+	}).replace(/\s+/g, " ").slice(0, 2e3);
+}
+/** Report Slack warnings once, on the request span, without retrying the post. */
+function captureSlackPostWarning(response, attributes) {
+	const warnings = response.response_metadata?.warnings ?? [];
+	const messages = response.response_metadata?.messages ?? [];
+	const knownCodes = [...new Set(warnings.slice(0, 20).filter((code) => codes.has(code)))].sort();
+	const diagnostics = {
+		"app.slack.warning_count": warnings.length,
+		"app.slack.response_message_count": messages.length,
+		"app.slack.diagnostic_codes": knownCodes
+	};
+	setSpanAttributes(diagnostics);
+	if (!warnings.length && !messages.length) return;
+	captureMessage("Slack chat.postMessage returned warnings", {
+		level: "warning",
+		fingerprint: ["slack.chat.postMessage.warning", ...knownCodes.length ? knownCodes : ["unknown"]],
+		tags: { "app.slack.method": "chat.postMessage" },
+		extra: {
+			...getLogContextAttributes(),
+			...attributes,
+			...diagnostics,
+			"app.slack.response_diagnostics": {
+				warnings: warnings.slice(0, 20).map(summarizeDiagnostic),
+				messages: messages.slice(0, 20).map(summarizeDiagnostic)
+			}
+		}
+	});
+}
+//#endregion
+//#region src/chat/slack/work-object.ts
+const url = z.url({ protocol: /^https?$/ });
+const textField = z.strictObject({
+	type: z.literal("string"),
+	key: z.string().min(1),
+	label: z.string().min(1),
+	value: z.string(),
+	long: z.boolean().optional(),
+	format: z.literal("markdown").optional(),
+	link: url.optional()
+}).refine((field) => !field.format || !field.link, { message: "Slack string fields cannot combine format and link" });
+const customField = z.discriminatedUnion("type", [textField, z.strictObject({
+	type: z.literal("slack#/types/timestamp"),
+	key: z.string().min(1),
+	label: z.string().min(1),
+	value: z.number().int(),
+	link: url.optional()
+})]);
+const payload = z.strictObject({
+	attributes: z.strictObject({
+		title: z.strictObject({ text: z.string().min(1) }),
+		display_id: z.string().optional(),
+		display_type: z.string().optional(),
+		product_name: z.string().optional(),
+		product_icon: z.strictObject({
+			url,
+			alt_text: z.string().min(1)
+		}).optional()
+	}),
+	custom_fields: z.array(customField).optional(),
+	display_order: z.array(z.string()).optional()
+});
+/** Limit IDs to Junior's safe subset; Slack silently rejects JSON punctuation. */
+const slackExternalRefIdSchema = z.string().min(1).regex(/^[A-Za-z0-9_-]+$/, "Unsupported Slack external reference ID");
+const entity = z.strictObject({
+	external_ref: z.strictObject({
+		id: slackExternalRefIdSchema,
+		type: z.string().min(1).optional()
+	}),
+	url
+});
+/** Validate notification and detail metadata before Slack can ignore bad fields. */
+const slackEntitySchema = z.discriminatedUnion("entity_type", [entity.extend({
+	entity_type: z.literal("slack#/entities/item"),
+	entity_payload: payload.extend({ fields: z.never().optional() })
+}), entity.extend({
+	entity_type: z.literal("slack#/entities/task"),
+	entity_payload: payload.extend({ fields: z.strictObject({ status: z.strictObject({ value: z.string() }).optional() }).optional() })
+})]);
+//#endregion
+//#region src/chat/slack/outbound.ts
+const MAX_SLACK_MESSAGE_TEXT_CHARS = 4e4;
+function requireSlackConversationId(channelId, action) {
+	const normalized = normalizeSlackConversationId(channelId);
+	if (!normalized) throw new Error(`${action} requires a valid channel ID`);
+	return normalized;
+}
+function requireSlackThreadTimestamp(threadTs, action) {
+	const normalized = threadTs.trim();
+	if (!normalized) throw new Error(`${action} requires a thread timestamp`);
+	return normalized;
+}
+function requireSlackMessageTimestamp(timestamp, action) {
+	const normalized = parseSlackMessageTs(timestamp);
+	if (!normalized) throw new Error(`${action} requires a target message timestamp`);
+	return normalized;
+}
+function requireSlackMessageText(text, action) {
+	if (text.trim().length === 0) throw new Error(`${action} requires non-empty text`);
+	if (text.length > MAX_SLACK_MESSAGE_TEXT_CHARS) throw new Error(`${action} text exceeds Slack's 40000 character truncation limit`);
+	return text;
+}
+/** Resolve a Slack message permalink without making read-only workflows fail on lookup errors. */
+async function getSlackMessagePermalink(args) {
+	try {
+		return (await withSlackRetries(() => getSlackClient().chat.getPermalink({
+			channel: args.channelId,
+			message_ts: args.messageTs
+		}), 3, {
+			action: "chat.getPermalink",
+			idempotent: true,
+			spanAttributes: {
+				"app.slack.channel_id": args.channelId,
+				"app.slack.message_ts": args.messageTs
+			}
+		})).permalink;
+	} catch {
+		return;
+	}
+}
+/** Open the bot's direct message with one Slack user and return its channel ID. */
+async function openSlackDirectMessage(userId) {
+	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 channel.");
+	return channelId;
+}
+/** Post Slack `mrkdwn` text to a conversation or thread via the shared outbound boundary. */
+async function postSlackMessage(input) {
+	const channelId = requireSlackConversationId(input.channelId, "Slack message posting");
+	const text = requireSlackMessageText(input.text, "Slack message posting");
+	const entities = input.entities?.length ? slackEntitySchema.array().parse(input.entities) : void 0;
+	const threadTs = input.threadTs ? requireSlackThreadTimestamp(input.threadTs, "Slack thread message posting") : void 0;
+	const attributes = {
+		"app.slack.channel_id": channelId,
+		...threadTs ? { "app.slack.thread_ts": threadTs } : void 0,
+		"app.slack.work_object.count": entities?.length ?? 0
+	};
+	const response = await withSlackRetries(async () => {
+		const response = await getSlackClient().chat.postMessage({
+			channel: channelId,
+			text,
+			unfurl_links: false,
+			unfurl_media: false,
+			...input.blocks?.length ? { blocks: input.blocks } : void 0,
+			...entities ? { metadata: { entities } } : void 0,
+			...threadTs ? { thread_ts: threadTs } : void 0
+		});
+		const messageId = parseSlackMessageTs(response.ts);
+		setSpanAttributes({ "messaging.message.id": messageId });
+		captureSlackPostWarning(response, {
+			...attributes,
+			"messaging.message.id": messageId
+		});
+		return response;
+	}, 3, {
+		action: "chat.postMessage",
+		attributes
+	});
+	const messageTs = parseSlackMessageTs(response.ts);
+	if (!messageTs) throw new Error("Slack message posted without ts");
+	return {
+		ts: messageTs,
+		...input.includePermalink ? { permalink: await getSlackMessagePermalink({
+			channelId,
+			messageTs
+		}) } : void 0
+	};
+}
+/**
+* Post an ephemeral Slack message. Delivery is best-effort on Slack's side, but
+* request validation and Web API behavior are centralized here.
+*/
+async function postSlackEphemeralMessage(input) {
+	const channelId = requireSlackConversationId(input.channelId, "Slack ephemeral message posting");
+	const userId = parseSlackUserId(input.userId);
+	if (!userId) throw new Error("Slack ephemeral message posting requires a user ID");
+	const text = requireSlackMessageText(input.text, "Slack ephemeral message posting");
+	const threadTs = input.threadTs ? requireSlackThreadTimestamp(input.threadTs, "Slack ephemeral thread message posting") : void 0;
+	return { messageTs: (await withSlackRetries(() => getSlackClient().chat.postEphemeral({
+		channel: channelId,
+		user: userId,
+		text,
+		...input.blocks?.length ? { blocks: input.blocks } : void 0,
+		...threadTs ? { thread_ts: threadTs } : void 0
+	}), 3, {
+		action: "chat.postEphemeral",
+		spanAttributes: {
+			"app.slack.channel_id": channelId,
+			"app.slack.user_id": userId,
+			...threadTs ? { "app.slack.thread_ts": threadTs } : void 0
+		}
+	})).message_ts };
+}
+/** Upload files into a Slack conversation or thread via the shared outbound file boundary. */
+async function uploadFilesToConversation(input) {
+	const channelId = requireSlackConversationId(input.channelId, "Slack file upload");
+	const threadTs = input.threadTs ? requireSlackThreadTimestamp(input.threadTs, "Slack file upload") : void 0;
+	if (input.files.length === 0) throw new Error("Slack file upload requires at least one file");
+	const fileUploads = input.files.map((file) => {
+		const filename = file.filename.trim();
+		if (!filename) throw new Error("Slack file upload requires every file to have a filename");
+		return {
+			file: file.data,
+			filename
+		};
+	});
+	return { files: ((await withSlackRetries(() => getSlackClient().filesUploadV2({
+		channel_id: channelId,
+		...threadTs ? { thread_ts: threadTs } : void 0,
+		file_uploads: fileUploads
+	}), 3, {
+		action: "filesUploadV2",
+		spanAttributes: {
+			"app.slack.channel_id": channelId,
+			...threadTs ? { "app.slack.thread_ts": threadTs } : void 0
+		}
+	})).files ?? []).flatMap((completion) => (completion.files ?? []).map((file) => file.id ? { id: file.id } : {})) };
+}
+/** Add a reaction to a Slack message, treating `already_reacted` as idempotent success. */
+async function addReactionToMessage(input) {
+	const channelId = requireSlackConversationId(input.channelId, "Slack reaction");
+	const timestamp = requireSlackMessageTimestamp(input.timestamp, "Slack reaction");
+	const emoji = normalizeSlackEmojiName(input.emoji);
+	if (!emoji) throw new Error("Slack reaction requires a valid emoji alias name");
+	try {
+		await withSlackRetries(() => getSlackClient(input.timeoutMs === void 0 ? void 0 : { timeoutMs: input.timeoutMs }).reactions.add({
+			channel: channelId,
+			timestamp,
+			name: emoji
+		}), input.timeoutMs === void 0 ? 3 : 1, {
+			action: "reactions.add",
+			idempotent: true,
+			spanAttributes: {
+				"app.slack.channel_id": channelId,
+				"app.slack.message_ts": timestamp,
+				"app.slack.reaction": emoji
+			}
+		});
+	} catch (error) {
+		if (error instanceof SlackActionError && error.code === "already_reacted") return { ok: true };
+		throw error;
+	}
+	return { ok: true };
+}
+/** Remove a reaction from a Slack message, treating `no_reaction` as idempotent success. */
+async function removeReactionFromMessage(input) {
+	const channelId = requireSlackConversationId(input.channelId, "Slack reaction removal");
+	const timestamp = requireSlackMessageTimestamp(input.timestamp, "Slack reaction removal");
+	const emoji = normalizeSlackEmojiName(input.emoji);
+	if (!emoji) throw new Error("Slack reaction removal requires a valid emoji alias name");
+	try {
+		await withSlackRetries(() => getSlackClient().reactions.remove({
+			channel: channelId,
+			timestamp,
+			name: emoji
+		}), 3, {
+			action: "reactions.remove",
+			idempotent: true,
+			spanAttributes: {
+				"app.slack.channel_id": channelId,
+				"app.slack.message_ts": timestamp,
+				"app.slack.reaction": emoji
+			}
+		});
+	} catch (error) {
+		if (error instanceof SlackActionError && error.code === "no_reaction") return { ok: true };
+		throw error;
+	}
+	return { ok: true };
+}
+//#endregion
+//#region src/chat/slack/status-format.ts
+const SLACK_STATUS_MAX_LENGTH = 50;
+/** Truncate a status string to fit Slack's 50-char assistant status limit. */
+function truncateStatusText(text) {
+	const trimmed = text.trim();
+	if (!trimmed) return "";
+	if (trimmed.length <= SLACK_STATUS_MAX_LENGTH) return trimmed;
+	return `${trimmed.slice(0, 47).trimEnd()}...`;
+}
+//#endregion
+//#region src/chat/slack/mrkdwn.ts
+/** Escape dynamic text for Slack mrkdwn without changing intended formatting. */
+function escapeSlackMrkdwnText(text) {
+	return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+/** Escape a URL for Slack explicit link syntax while preserving query semantics. */
+function escapeSlackLinkUrl(url) {
+	return url.replaceAll("&", "&amp;").replaceAll("<", "%3C").replaceAll(">", "%3E");
+}
+/** Build a Slack explicit link from dynamic URL and label values. */
+function formatSlackLink(url, label) {
+	return `<${escapeSlackLinkUrl(url)}|${escapeSlackMrkdwnText(label)}>`;
+}
+function readInlineCodeSpan(line, start) {
+	if (line[start] !== "`") return;
+	let n = 1;
+	while (line[start + n] === "`") n++;
+	const marker = "`".repeat(n);
+	let search = start + n;
+	while (search < line.length) {
+		const close = line.indexOf(marker, search);
+		if (close === -1) return;
+		const after = close + n;
+		if (line[after] !== "`") return {
+			text: line.slice(start, after),
+			end: after
+		};
+		search = after + 1;
+	}
+}
+function readExistingSlackAngleToken(line, start) {
+	if (line[start] !== "<") return;
+	const close = line.indexOf(">", start + 1);
+	if (close === -1) return;
+	const body = line.slice(start + 1, close);
+	if (/^(?:https?:\/\/|@|#|!)/.test(body)) return {
+		text: line.slice(start, close + 1),
+		end: close + 1
+	};
+}
+function readMarkdownLink(line, start) {
+	if (line[start] !== "[") return;
+	const labelEnd = line.indexOf("](", start + 1);
+	if (labelEnd === -1) return;
+	const destStart = labelEnd + 2;
+	if (!line.startsWith("http://", destStart) && !line.startsWith("https://", destStart)) return;
+	const closeParens = line.indexOf(")", destStart);
+	if (closeParens === -1) return;
+	return {
+		text: line.slice(start, closeParens + 1),
+		end: closeParens + 1
+	};
+}
+function hasUnmatchedClosingParen(text) {
+	let balance = 0;
+	for (const ch of text) if (ch === "(") balance++;
+	else if (ch === ")") balance--;
+	return balance < 0;
+}
+function readBareUrl(line, start) {
+	let end = start;
+	while (end < line.length) {
+		const ch = line[end];
+		if (/\s/.test(ch) || ch === "<" || ch === ">" || ch === "\"" || ch === "`" || ch === "|" || ch === "*") break;
+		end++;
+	}
+	if (end === start) return;
+	let raw = line.slice(start, end);
+	let suffix = "";
+	const peel = () => {
+		suffix = raw.slice(-1) + suffix;
+		raw = raw.slice(0, -1);
+	};
+	const shouldPeel = () => raw.endsWith("_") || /[.,!?;:]$/.test(raw) || raw.endsWith(")") && hasUnmatchedClosingParen(raw);
+	while (raw.length > 0 && shouldPeel()) peel();
+	if (!/^https?:\/\/.+/.test(raw)) return;
+	return {
+		url: raw,
+		suffix,
+		end
+	};
+}
+/** Wrap bare http(s) URLs on a single line as Slack explicit `<url>` links. */
+function wrapBareUrlsOnLine(line) {
+	let result = "";
+	let i = 0;
+	while (i < line.length) {
+		const codeSpan = readInlineCodeSpan(line, i);
+		if (codeSpan) {
+			result += codeSpan.text;
+			i = codeSpan.end;
+			continue;
+		}
+		const angleToken = readExistingSlackAngleToken(line, i);
+		if (angleToken) {
+			result += angleToken.text;
+			i = angleToken.end;
+			continue;
+		}
+		const mdLink = readMarkdownLink(line, i);
+		if (mdLink) {
+			result += mdLink.text;
+			i = mdLink.end;
+			continue;
+		}
+		if (line.startsWith("https://", i) || line.startsWith("http://", i)) {
+			const parsed = readBareUrl(line, i);
+			if (parsed) {
+				result += `<${parsed.url}>${parsed.suffix}`;
+				i = parsed.end;
+				continue;
+			}
+		}
+		result += line[i];
+		i++;
+	}
+	return result;
+}
+/**
+* Pre-wrap bare http(s) URLs outside fenced code blocks as Slack explicit
+* links, preventing Slack's auto-linker from consuming adjacent formatting
+* markers into the URL.
+*
+* Uses the same fence-toggle rule as `ensureBlockSpacing` so both passes
+* agree on which lines are code.
+*/
+function wrapBareUrls(text) {
+	const lines = text.split("\n");
+	const out = [];
+	let inCodeBlock = false;
+	for (const line of lines) {
+		if (line.trimStart().startsWith("```")) {
+			inCodeBlock = !inCodeBlock;
+			out.push(line);
+			continue;
+		}
+		out.push(inCodeBlock ? line : wrapBareUrlsOnLine(line));
+	}
+	return out.join("\n");
+}
+/** Insert blank lines between content blocks so Slack renders them with visual separation. */
+function ensureBlockSpacing(text) {
+	const codeBlockPattern = /^```/;
+	const listItemPattern = /^[-*•]\s|^\d+\.\s/;
+	const lines = text.split("\n");
+	const result = [];
+	let inCodeBlock = false;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (codeBlockPattern.test(line.trimStart())) {
+			if (!inCodeBlock) {
+				const prev = result.length > 0 ? result[result.length - 1] : void 0;
+				if (prev !== void 0 && prev.trim() !== "") result.push("");
+			}
+			inCodeBlock = !inCodeBlock;
+			result.push(line);
+			continue;
+		}
+		if (inCodeBlock) {
+			result.push(line);
+			continue;
+		}
+		const prev = result.length > 0 ? result[result.length - 1] : void 0;
+		if (prev !== void 0 && prev.trim() !== "" && line.trim() !== "" && !(listItemPattern.test(prev.trimStart()) && listItemPattern.test(line.trimStart()))) result.push("");
+		result.push(line);
+	}
+	return result.join("\n");
+}
+/**
+* Normalize model-authored Slack markdown for delivery via `markdown_text`
+* or `{ type: "markdown" }` blocks.
+*
+* Plugins may first rewrite ordinary Markdown. Core then applies Slack-only
+* delivery shaping: bare URL wrapping and block spacing. Slack reply delivery
+* owns chunking and continuation markers separately.
+*/
+function normalizeSlackReplyMarkdown(text) {
+	let normalized = applyPluginFormatMarkdown(text).replace(/\r\n?/g, "\n").replace(/[ \t]+$/gm, "");
+	normalized = wrapBareUrls(normalized);
+	normalized = ensureBlockSpacing(normalized);
+	return normalized.replace(/\n{3,}/g, "\n\n").trim();
+}
+/** Normalize assistant status text before handing it to Slack. */
+function normalizeSlackStatusText(text) {
+	const trimmed = text.trim();
+	if (!trimmed) return "";
+	return truncateStatusText(trimmed.replace(/(?:\.\s*)+$/, "").trim());
+}
+/** Render a Slack user mention, which Slack shows as the person's name. */
+function slackMention(userId) {
+	return `<@${userId}>`;
+}
+//#endregion
+//#region src/chat/automations/revision.ts
+/** Storage revisions prevent stale edits from replacing newer values. */
+var AutomationConflictError = class extends ToolInputError {
+	constructor() {
+		super("This Automation changed after it was loaded. Reload it before saving.");
+		this.name = "AutomationConflictError";
+	}
+};
+/** Sort object keys so equal values produce equal JSON. */
+function canonicalJson(value) {
+	if (Array.isArray(value)) return value.map(canonicalJson);
+	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, child]) => [key, canonicalJson(child)]));
+	return value;
+}
+/** Identify the stored values being edited, including lifecycle and creator authority. */
+function automationRevision(task) {
+	return createHash("sha256").update(JSON.stringify(canonicalJson(task))).digest("hex");
+}
+/** Reject a stale edit while the storage owner holds the write lock. */
+function requireAutomationRevision(task, revision) {
+	if (!task || automationRevision(task) !== revision) throw new AutomationConflictError();
+}
+//#endregion
+//#region src/chat/automations/versions.ts
+/** Automation versions keep each saved definition so people can see how it changed. */
+/** Return the versioned part of an Automation. Lifecycle and run state are excluded. */
+function automationDefinition(task) {
+	const common = {
+		title: task.title?.trim() || null,
+		instruction: task.task.text,
+		credentialMode: task.credentialMode,
+		destination: task.destination,
+		outcomes: task.outcomes
+	};
+	return "schedule" in task ? {
+		...common,
+		schedule: task.schedule
+	} : {
+		...common,
+		trigger: task.trigger
+	};
+}
+/** Compare definition values after key sorting. */
+function sameDefinitionValue(left, right) {
+	return JSON.stringify(canonicalJson(left)) === JSON.stringify(canonicalJson(right));
+}
+/**
+* Save a version when the definition changed. Call this in the same
+* transaction and lock as the Automation write. Without `current`, the
+* Automation is new, so the creator saves version 1.
+*/
+async function recordAutomationVersion(db, kind, 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}
+    )`,
+		createdAtMs: Date.now(),
+		editedBy: editedBy ?? (current ? null : task.createdBy),
+		definition
+	});
+}
+function parseVersionRow(kind, row) {
+	return automationVersionSchema.parse({
+		kind,
+		version: row.version,
+		createdAt: new Date(row.createdAtMs).toISOString(),
+		editedBy: row.editedBy,
+		definition: row.definition
+	});
+}
+/** 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;
+}
+/** 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));
+}
+//#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;
+}
+/** Decode a retained event Automation 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 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",
+		...row.statusReason ? { statusReason: row.statusReason } : void 0,
+		...title ? { title } : void 0
+	};
+}
+function activeEventAutomationWhere() {
+	return ne(juniorEventAutomations.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);
+	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;
+	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 });
+		if (inserted[0]) {
+			const created = parseEventAutomationRow(inserted[0]);
+			await recordAutomationVersion(tx, "event", created, void 0);
+			return created;
+		}
+		const existing = await getEventAutomation(tx, parsed.id);
+		if (!existing) return {
+			...parsed,
+			status: "active",
+			...title ? { title } : void 0
+		};
+		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,
+			status: "active",
+			...title ? { title } : void 0
+		};
+		const revived = parseEventAutomationRow(rows[0]);
+		await recordAutomationVersion(tx, "event", revived, void 0);
+		return revived;
+	});
+}
+/**
+* Replace an existing non-deleted event automation under a row lock.
+* Pass `editedBy` when a person changes the definition so its version names them.
+*/
+async function saveEventAutomation(db, task, expectedRevision, editedBy) {
+	const parsed = eventAutomationSchema.parse(eventAutomationJsonPayload(task));
+	const title = task.title?.trim() || null;
+	return db.transaction(async (tx) => {
+		const rows = await tx.select({ ...eventAutomationRowColumns }).from(juniorEventAutomations).where(eq(juniorEventAutomations.id, parsed.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);
+		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 });
+	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);
+}
+function viewerSlackIdentities(user) {
+	return user.identities.filter((identity) => identity.provider === "slack" && Boolean(identity.providerTenantId) && Boolean(identity.providerSubjectId));
+}
+/** 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 deleted event automations created by one user, newest first.
+* Used only to keep historical runs after the live automation list drops the row.
+*/
+async function listDeletedEventAutomationsCreatedBy(db, user, limit) {
+	const identities = viewerSlackIdentities(user);
+	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({ ...eventAutomationRowColumns }).from(juniorEventAutomations).where(and(ownership, eq(juniorEventAutomations.status, "deleted"))).orderBy(desc(juniorEventAutomations.createdAtMs), desc(juniorEventAutomations.id)).limit(limit)).map(parseEventAutomationRow);
+}
+/**
+* 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 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 keys = /* @__PURE__ */ new Set();
+	for (const row of rows) {
+		const task = parseEventAutomationRow(row);
+		if (!task.trigger.events.some((eventType) => eventTypes.has(eventType))) continue;
+		for (const key of Object.keys(task.trigger.match ?? {})) keys.add(key);
+	}
+	return [...keys].sort();
+}
+/** 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));
+}
+/**
+* Change lifecycle under the same row lock as edits, without changing
+* credentials. A pause keeps an unresolved block reason, so resuming a paused
+* blocked automation returns it to blocked. Resume a blocked automation to
+* clear the reason.
+*/
+async function setEventAutomationStatus(db, id, status, revision) {
+	return db.transaction(async (tx) => {
+		const rows = await tx.select().from(juniorEventAutomations).where(eq(juniorEventAutomations.id, id)).for("update");
+		const current = rows[0] ? parseEventAutomationRow(rows[0]) : void 0;
+		requireAutomationRevision(current, revision);
+		if (!current || current.status === "deleted") throw new Error("Automation no longer exists.");
+		const next = status === "paused" ? {
+			status,
+			statusReason: current.statusReason
+		} : current.status === "paused" && current.statusReason ? {
+			status: "blocked",
+			statusReason: current.statusReason
+		} : {
+			status,
+			statusReason: void 0
+		};
+		await tx.update(juniorEventAutomations).set({
+			status: next.status,
+			statusReason: next.statusReason ?? null
+		}).where(eq(juniorEventAutomations.id, id));
+		const { statusReason: _statusReason, ...rest } = current;
+		return {
+			...rest,
+			status: next.status,
+			...next.statusReason ? { statusReason: next.statusReason } : void 0
+		};
+	});
+}
+/**
+* Stop an event automation after a run reports a problem that only its
+* creator can fix. An active automation becomes blocked. A paused automation
+* stays paused and keeps the reason, so resume returns it to blocked.
+* Deleted automations do not change. Returns true only when this call set
+* the automation to blocked, so the creator notice goes once and never for
+* an automation that the dashboard shows as paused.
+*/
+async function blockEventAutomation(db, id, reason) {
+	return (await db.update(juniorEventAutomations).set({
+		status: sql`case when ${juniorEventAutomations.status} = 'active' then 'blocked' else ${juniorEventAutomations.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";
+}
+//#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. */
+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
+	};
+}
+/** Keep scan paths from returning current or legacy tombstones. */
+function isListedScheduledAutomation(task) {
+	return task !== void 0 && task.status !== "deleted";
+}
+/** Build the stable run id for one task occurrence. */
+function scheduledRunId(taskId, scheduledForMs) {
+	return `${taskId}:${scheduledForMs}`;
+}
+/** Acquire the deployed advisory lock for one scheduled automation. */
+function withScheduledAutomationLock(db, taskId, callback) {
+	return db.transaction(async (tx) => {
+		await tx.execute(sql`SELECT pg_advisory_xact_lock(hashtext(${`${SCHEDULER_KEY_PREFIX}:task:${taskId}:lock`}))`);
+		return await callback(tx);
+	});
+}
+function requireStoredTask(task) {
+	const parsed = scheduledAutomationSchema.safeParse(task);
+	if (!parsed.success) throw new Error("Scheduled automation routing context is invalid.");
+	const { title, ...current } = parsed.data;
+	const normalizedTitle = title?.trim() || void 0;
+	return {
+		...current,
+		...normalizedTitle ? { title: normalizedTitle } : void 0
+	};
+}
+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
+	}).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`
+		}
+	});
+}
+/** 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] ? 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);
+}
+/** List decoded scheduled automations in stable creation order. */
+async function listScheduledAutomations(db) {
+	return await readListedScheduledAutomations(db);
+}
+/** List decoded scheduled automations for one team in stable creation order. */
+async function listScheduledAutomationsForTeam(db, teamId) {
+	return await readListedScheduledAutomations(db, teamId);
+}
+async function writeScheduledAutomation(db, task, current, editedBy) {
+	if (current?.status === "blocked" && task.status === "active" && typeof task.nextRunAtMs === "number" && Number.isFinite(task.nextRunAtMs)) await db.delete(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);
+}
+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")));
+	}
+}
+/** Create a scheduled automation once under its retry-stable task lock. */
+async function createScheduledAutomation(db, task) {
+	const next = requireStoredTask(task);
+	return await withScheduledAutomationLock(db, task.id, async (tx) => {
+		const current = await readScheduledAutomation(tx, task.id);
+		if (current) return current;
+		await writeScheduledAutomation(tx, next, void 0);
+		return next;
+	});
+}
+/**
+* Save a scheduled automation and clear its blocked occurrence on reactivation.
+* Pass `editedBy` when a person changes the definition so its version names them.
+*/
+async function saveScheduledAutomation(db, task, expectedRevision, editedBy) {
+	const next = requireStoredTask(task);
+	await withScheduledAutomationLock(db, task.id, async (tx) => {
+		const current = await readScheduledAutomation(tx, task.id);
+		if (expectedRevision !== void 0) requireAutomationRevision(current, expectedRevision);
+		await writeScheduledAutomation(tx, next, current, editedBy);
+	});
+	return next;
+}
+/** Save a scheduled automation inside a task lock already held by the caller. */
+async function saveScheduledAutomationInLock(db, task, current) {
+	await writeScheduledAutomation(db, requireStoredTask(task), current);
+}
+//#endregion
+export { persistWithRetry as $, markConversationMessage as $t, formatSlackLink as A, recordAuthenticationLinked as At, removeReactionFromMessage as B, persistConversationMessages as Bt, listAutomationVersions as C, loadConversationProjection as Ct, automationRevision as D, openConversationProjection as Dt, AutomationConflictError as E, loadTurnRoute as Et, addReactionToMessage as F, recordSubscribedReplyRoute as Ft, loadTurnCheckpoint as G, fallbackShortTitle as Gt, slackEntitySchema as H, persistConversationMessageSummaries as Ht, getSlackMessagePermalink as I, recordToolExecutionStarted as It, completeTurnRecord as J, buildConversationContext as Jt, saveTurnCheckpoint as K, resolveTaskTitle as Kt, openSlackDirectMessage as L, recordTurnRoute as Lt, normalizeSlackStatusText as M, recordAuthorizationRequested as Mt, slackMention as N, recordGuardianActionReviewed as Nt, requireAutomationRevision as O, recordAgentsInstructionsUpdated as Ot, truncateStatusText as P, recordMcpProviderConnected as Pt, recordTurnSummary as Q, isHumanConversationMessage as Qt, postSlackEphemeralMessage as R, appendConversationMessages as Rt, automationDefinition as S, loadConnectedMcpProviders as St, sameDefinitionValue as T, loadTurnProjection as Tt, slackExternalRefIdSchema as U, resolveConversationTitle as Ut, uploadFilesToConversation as V, projectConversationMessages as Vt, continuableMessages as W, settleConversationTitleWork as Wt, getTurnRecord as X, estimateConversationContextTokens as Xt, failTurnRecord as Y, createConversationMemoryService as Yt, listTurnSummaries as Z, getConversationMessageSlackTs as Zt, listDeletedEventAutomationsCreatedBy as _, trimTrailingAssistantMessages as _t, readScheduledAutomation as a, getAgentContextCompactionTriggerTokens as an, getPiMessageRole as at, saveEventAutomation as b, commitAcceptedReply as bt, scheduledRunId as c, piMessageFromHistoryItem as cn, hasRuntimeTurnContext as ct, collectEventAutomationMatchKeys as d, isContinuablePiBoundary as dt, normalizeConversationText as en, TurnSliceLimitExceededError as et, createEventAutomation as f, isToolResultError as ft, getEventAutomation as g, stripRuntimeTurnContext as gt, findMatchingEventAutomations as h, retainRuntimeTurnContext as ht, parseScheduledAutomationRow as i, estimateTextTokens as in, extractAssistantText as it, normalizeSlackReplyMarkdown as j, recordAuthorizationCompleted as jt, escapeSlackMrkdwnText as k, recordAttachmentsDelivered as kt, withScheduledAutomationLock as l, instructionTextForProjection as lt, eventAutomationBelongsToUser as m, normalizeToolNameFromResult as mt, listScheduledAutomations as n, turnHasReply as nn, buildTurnErrorResponse as nt, saveScheduledAutomation as o, getAgentContextInputLimitTokens as on, getTerminalAssistantMessages as ot, deleteEventAutomation as p, isToolResultMessage as pt, abandonTurnRecord as q, appendThreadContextMessages as qt, listScheduledAutomationsForTeam as r, upsertConversationMessage as rn, isTurnExecutionLimitExceededError as rt, saveScheduledAutomationInLock as s, historyItemFromPiMessage as sn, getUserMessageInstructionText as st, createScheduledAutomation as t, recordDeliveredAssistantMessage as tn, assertTurnToolCallLimit as tt, blockEventAutomation as u, isAssistantMessage as ut, listEventAutomationsForTeam as v, TURN_CONTEXT_TAG as vt, readAutomationVersion as w, loadProjection as wt, setEventAutomationStatus as x, commitMessages as xt, parseEventAutomationRow as y, ToolInputError as yt, postSlackMessage as z, hydrateConversationMessages as zt };