@sentry/junior 0.224.0 → 0.226.0

package/dist/stats-DP9zl3Jg.js

@@ -1,2758 +0,0 @@
-import { F as isRecord$1, I as toOptionalNumber, L as toOptionalString } from "./logging-iY0ssa2q.js";
-import { a as getChatConfig } from "./config-BAhl7-RC.js";
-import { _ as parseSlackMessageTs, d as parseStoredSlackActor, h as parseSlackTeamId, p as parseSlackChannelId } from "./context-Bplcgypl.js";
-import { Ft as saveObjectAnnotations, J as withSlackRetries, Kt as getConversationStore, U as getSlackClient, fn as parseDestination, ht as getDashboardTaskLink, mn as sameDestination, pt as JUNIOR_THREAD_STATE_TTL_MS, qt as getDb, u as getPlugins } from "./agent-hooks-DNLBwmsh.js";
-import { n as juniorDestinations } from "./destinations-BeBiJeEM.js";
-import { E as juniorConversations, a as juniorSchedulerRuns, c as juniorStats, l as juniorEventAutomations, o as juniorSchedulerTasks, w as juniorAttachments } from "./executor-BG2Armby.js";
-import { t as fallbackShortTitle } from "./short-title-xEkZwkcV.js";
-import { C as getDefaultRedisStateAdapterFor, w as getStateAdapter } from "./profile-6KWhg_-U.js";
-import "./vercel-queue-DIkVcfK4.js";
-import { z } from "zod";
-import { createHash, randomUUID } from "node:crypto";
-import { and, asc, desc, eq, gte, inArray, isNotNull, isNull, lte, ne, notInArray, or, sql } from "drizzle-orm";
-import { actorUserIdSchema, destinationSchema, destinationVisibilitySchema, eventMatchSchema, eventMatches, eventTypeSchema, normalizeEventIdentifier, ownedObjectAnnotationSchema, slackDestinationSchema, taskOutcomeSchema } from "@sentry/junior-plugin-api";
-//#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/state/turn-id.ts
-/** Build a stable turn identifier from a message ID. */
-function buildDeterministicTurnId(messageId) {
-	return `turn_${messageId.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
-}
-/** Build the stable visible assistant-message identity for one logical turn. */
-function buildDeterministicAssistantMessageId(turnId) {
-	return `${turnId}:assistant:1`;
-}
-//#endregion
-//#region src/chat/tool-support/structured-result.ts
-const juniorToolContinuationSchema = z.object({
-	arguments: z.record(z.string(), z.unknown()),
-	reason: z.string().min(1).optional()
-}).strict();
-const juniorToolBoundContinuationSchema = juniorToolContinuationSchema.extend({ tool_name: z.string().min(1) });
-/** Shared optional fields for canonical Junior tool outputs. */
-const juniorToolOutputSchema = z.object({
-	target: z.string().min(1).optional(),
-	truncated: z.boolean().optional(),
-	/** True when this attempt did not finish before its time budget. */
-	timed_out: z.boolean().optional(),
-	continuation: juniorToolContinuationSchema.optional()
-}).passthrough();
-function sortJsonValue(value) {
-	if (Array.isArray(value)) return value.map(sortJsonValue);
-	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, sortJsonValue(item)]));
-}
-function isRecord(value) {
-	return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-/** Bind continuation metadata to the exposed runtime tool name. */
-function injectContinuationToolName(details, toolName) {
-	if (!isRecord(details) || !isRecord(details.continuation)) return details;
-	return {
-		...details,
-		continuation: juniorToolBoundContinuationSchema.parse({
-			...details.continuation,
-			tool_name: toolName
-		})
-	};
-}
-function makeStructuredToolOutput(details, options = {}) {
-	return {
-		content: [{
-			type: "text",
-			text: JSON.stringify(sortJsonValue(details))
-		}, ...options.content ?? []],
-		details
-	};
-}
-//#endregion
-//#region src/chat/task-execution/state.ts
-/**
-* Expiring conversation mailbox and execution index store.
-*
-* The conversation record owns pending inbound work, execution status, and the
-* lease. `conversation:active` feeds heartbeat recovery and contains every
-* non-idle conversation until the lease/status path makes it idle.
-* `conversation:by-activity` supports legacy SQL import only; SQL owns durable
-* conversation metadata in configured runtime.
-*/
-const CONVERSATION_PREFIX = "junior:conversation:v2";
-const CONVERSATION_SCHEMA_VERSION = 2;
-const CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH = 1e4;
-const CONVERSATION_INDEX_LOCK_TTL_MS = 1e4;
-const CONVERSATION_INDEX_LOCK_WAIT_MS = 2e3;
-const CONVERSATION_INDEX_LOCK_RETRY_MS = 25;
-const CONVERSATION_MUTATION_LOCK_TTL_MS = 1e4;
-const CONVERSATION_MUTATION_WAIT_MS = 1e4;
-const CONVERSATION_MUTATION_RETRY_MS = 25;
-var InvalidConversationRecordError = class extends Error {
-	constructor(conversationId) {
-		super(`Conversation record is invalid for ${conversationId}`);
-		this.name = "InvalidConversationRecordError";
-	}
-};
-/** Return whether an error means a stored conversation record failed validation. */
-function isInvalidConversationRecordError(error) {
-	return error instanceof InvalidConversationRecordError;
-}
-var ConversationMutationFencedError = class extends Error {
-	constructor(conversationId) {
-		super(`Conversation mutation lock was lost before write for ${conversationId}`);
-		this.name = "ConversationMutationFencedError";
-	}
-};
-const CONVERSATION_BY_ACTIVITY_INDEX_KEY = `${CONVERSATION_PREFIX}:by-activity`;
-const CONVERSATION_ACTIVE_INDEX_KEY = `${CONVERSATION_PREFIX}:active`;
-const CONVERSATION_WORK_LEASE_TTL_MS = 9e4;
-const CONVERSATION_WORK_CHECK_IN_INTERVAL_MS = 15e3;
-const CONVERSATION_WORK_STALE_ENQUEUE_MS = 6e4;
-const inboundMessageSourceSchema = z.enum([
-	"api",
-	"internal",
-	"local",
-	"plugin",
-	"event",
-	"scheduler",
-	"slack",
-	"web"
-]);
-const agentInputSchema = z.object({
-	attachments: z.array(z.unknown()).optional(),
-	authorId: z.string().min(1).optional(),
-	metadata: z.record(z.string(), z.unknown()).optional(),
-	text: z.string()
-}).strict().refine((input) => input.text.trim() || input.attachments?.length, { message: "agent input requires text or attachments" });
-/** Durable delivery modes for pending inbound mailbox work. */
-const inboundMessageDeliverySchema = z.enum(["defer", "interrupt"]);
-/** Redis mailbox shape kept for deployed workers that still require this field. */
-const storedInboundMessageSchema = z.object({
-	attemptCount: z.number().finite().optional(),
-	conversationId: z.string().refine((value) => value.trim().length > 0),
-	createdAtMs: z.number().finite(),
-	delivery: inboundMessageDeliverySchema,
-	destination: destinationSchema.optional(),
-	inboundMessageId: z.string().refine((value) => value.trim().length > 0),
-	injectedAtMs: z.number().finite().optional(),
-	input: agentInputSchema,
-	receivedAtMs: z.number().finite(),
-	source: inboundMessageSourceSchema
-}).strict().extend({ publishExternally: z.boolean() });
-function conversationKey(conversationId) {
-	return `${CONVERSATION_PREFIX}:${conversationId}`;
-}
-function conversationStopKey(conversationId) {
-	return `${CONVERSATION_PREFIX}:stop:${conversationId}`;
-}
-function indexLockKey(indexKey) {
-	return `${indexKey}:lock`;
-}
-function mutationLockKey(conversationId) {
-	return `${CONVERSATION_PREFIX}:mutation:${conversationId}`;
-}
-function now$1() {
-	return Date.now();
-}
-function compareMessages(left, right) {
-	return left.createdAtMs - right.createdAtMs || left.receivedAtMs - right.receivedAtMs || left.inboundMessageId.localeCompare(right.inboundMessageId);
-}
-function inputHasAttachments(input) {
-	return Array.isArray(input.attachments) && input.attachments.length > 0;
-}
-/**
-* Upgrade a still-pending payload when a duplicate source event carries file
-* attachments the stored copy lacks (Slack `app_mention`/`message` twins),
-* keeping the stored ordering timestamps and delivery attempts.
-*/
-function upgradedPendingMessage(stored, duplicate) {
-	const promotesInterrupt = stored.delivery === "defer" && duplicate.delivery === "interrupt";
-	const delivery = promotesInterrupt ? "interrupt" : stored.delivery;
-	const input = promotesInterrupt ? {
-		...duplicate.input,
-		...inputHasAttachments(duplicate.input) || !inputHasAttachments(stored.input) ? void 0 : { attachments: stored.input.attachments }
-	} : inputHasAttachments(duplicate.input) && !inputHasAttachments(stored.input) ? duplicate.input : stored.input;
-	if (input === stored.input && delivery === stored.delivery) return stored;
-	return {
-		...stored,
-		delivery,
-		input
-	};
-}
-function compareIndexDescending(left, right) {
-	return right.score - left.score || right.conversationId.localeCompare(left.conversationId);
-}
-function compareIndexAscending(left, right) {
-	return left.score - right.score || left.conversationId.localeCompare(right.conversationId);
-}
-function uniqueStrings(values) {
-	return [...new Set(values)];
-}
-function normalizeSource(value) {
-	const parsed = inboundMessageSourceSchema.safeParse(value);
-	return parsed.success ? parsed.data : void 0;
-}
-function normalizeExecutionStatus(value) {
-	if (value === "paused") return value;
-	if (value === "failed" || value === "idle" || value === "pending" || value === "running") return value;
-}
-function normalizeMessage(value) {
-	const parsed = storedInboundMessageSchema.safeParse(value);
-	if (!parsed.success) return;
-	const { publishExternally: _publishExternally, ...message } = parsed.data;
-	return message;
-}
-function storeMessage(message, publishExternally) {
-	return {
-		...message,
-		publishExternally
-	};
-}
-/** Whether this is the final attempt before an unacked message is dead-lettered. */
-function isFinalAttempt(message) {
-	return (message.attemptCount ?? 0) >= 4;
-}
-function normalizeActor(value) {
-	return parseStoredSlackActor(value);
-}
-function normalizeLease(value) {
-	if (!isRecord$1(value)) return;
-	const token = toOptionalString(value.token);
-	const acquiredAtMs = toOptionalNumber(value.acquiredAtMs);
-	const lastCheckInAtMs = toOptionalNumber(value.lastCheckInAtMs);
-	const expiresAtMs = toOptionalNumber(value.expiresAtMs);
-	if (!token || typeof acquiredAtMs !== "number" || typeof lastCheckInAtMs !== "number" || typeof expiresAtMs !== "number") return;
-	return {
-		token,
-		acquiredAtMs,
-		lastCheckInAtMs,
-		expiresAtMs
-	};
-}
-function normalizeStop(value) {
-	if (!isRecord$1(value)) return;
-	const inboundMessageIds = Array.isArray(value.inboundMessageIds) ? uniqueStrings(value.inboundMessageIds.filter((id) => typeof id === "string")) : [];
-	const runId = toOptionalString(value.runId);
-	return runId ? {
-		inboundMessageIds,
-		runId
-	} : void 0;
-}
-/** Decode execution state and repair idle records that still own work. */
-function normalizeExecution(conversationId, value) {
-	if (!isRecord$1(value)) return;
-	const status = normalizeExecutionStatus(value.status);
-	if (!status) return;
-	const pendingMessages = [];
-	if (Array.isArray(value.pendingMessages)) {
-		for (const rawMessage of value.pendingMessages) {
-			const message = normalizeMessage(rawMessage);
-			if (!message || message.conversationId !== conversationId) return;
-			if (message.injectedAtMs !== void 0) continue;
-			pendingMessages.push(message);
-		}
-		pendingMessages.sort(compareMessages);
-	}
-	const inboundMessageIds = Array.isArray(value.inboundMessageIds) ? uniqueStrings(value.inboundMessageIds.map((id) => typeof id === "string" ? id : void 0).filter((id) => Boolean(id))) : [];
-	const lease = normalizeLease(value.lease);
-	const runId = toOptionalString(value.runId);
-	return {
-		status: status === "idle" && lease ? "running" : status === "idle" && pendingMessages.length > 0 ? "pending" : status,
-		inboundMessageIds: uniqueStrings([...inboundMessageIds, ...pendingMessages.map((message) => message.inboundMessageId)]),
-		pendingCount: pendingMessages.length,
-		pendingMessages,
-		lease,
-		lastCheckpointAtMs: toOptionalNumber(value.lastCheckpointAtMs),
-		lastEnqueuedAtMs: toOptionalNumber(value.lastEnqueuedAtMs),
-		lastProgressAtMs: toOptionalNumber(value.lastProgressAtMs),
-		retryCount: toOptionalNumber(value.retryCount),
-		runId,
-		updatedAtMs: toOptionalNumber(value.updatedAtMs)
-	};
-}
-/** Decode current conversation records. */
-function normalizeConversation(conversationId, value) {
-	if (!isRecord$1(value) || value.schemaVersion !== CONVERSATION_SCHEMA_VERSION) return;
-	const storedConversationId = toOptionalString(value.conversationId);
-	const createdAtMs = toOptionalNumber(value.createdAtMs);
-	const lastActivityAtMs = toOptionalNumber(value.lastActivityAtMs);
-	const updatedAtMs = toOptionalNumber(value.updatedAtMs);
-	const execution = normalizeExecution(conversationId, value.execution);
-	const destination = value.destination === void 0 ? void 0 : parseDestination(value.destination);
-	if (storedConversationId !== conversationId || typeof createdAtMs !== "number" || typeof lastActivityAtMs !== "number" || typeof updatedAtMs !== "number" || !execution || value.destination !== void 0 && !destination) return;
-	if (execution.pendingMessages.length > 0 && execution.pendingMessages.some((message) => {
-		if (!message.destination) return false;
-		return !destination || !sameDestination(message.destination, destination);
-	})) return;
-	return {
-		schemaVersion: CONVERSATION_SCHEMA_VERSION,
-		conversationId,
-		createdAtMs,
-		lastActivityAtMs,
-		updatedAtMs,
-		execution,
-		...destination ? { destination } : void 0,
-		...toOptionalString(value.title) ? { title: toOptionalString(value.title) } : void 0,
-		...toOptionalString(value.channelName) ? { channelName: toOptionalString(value.channelName) } : void 0,
-		...normalizeActor(value.actor) ? { actor: normalizeActor(value.actor) } : void 0,
-		...normalizeSource(value.source) ? { source: normalizeSource(value.source) } : void 0
-	};
-}
-function emptyConversation(args) {
-	return {
-		schemaVersion: CONVERSATION_SCHEMA_VERSION,
-		conversationId: args.conversationId,
-		createdAtMs: args.nowMs,
-		lastActivityAtMs: args.nowMs,
-		updatedAtMs: args.nowMs,
-		...args.destination ? { destination: args.destination } : void 0,
-		...args.source ? { source: args.source } : void 0,
-		execution: {
-			status: "idle",
-			inboundMessageIds: [],
-			pendingCount: 0,
-			pendingMessages: [],
-			updatedAtMs: args.nowMs
-		}
-	};
-}
-function isLeaseActive(lease, nowMs) {
-	return Boolean(lease && lease.expiresAtMs > nowMs);
-}
-function pendingMessages(conversation) {
-	return [...conversation.execution.pendingMessages].sort(compareMessages);
-}
-function isRunnableStatus(status) {
-	return status !== "failed" && status !== "idle";
-}
-function hasRunnableWork(conversation) {
-	return isRunnableStatus(conversation.execution.status) || pendingMessages(conversation).length > 0;
-}
-function executionWithPendingMessages(execution, pending) {
-	const pendingMessages = [...pending].sort(compareMessages);
-	const status = execution.status === "idle" && execution.lease ? "running" : execution.status === "idle" && pendingMessages.length > 0 ? "pending" : execution.status;
-	return {
-		...execution,
-		status,
-		inboundMessageIds: uniqueStrings([...execution.inboundMessageIds, ...pendingMessages.map((message) => message.inboundMessageId)]),
-		pendingMessages,
-		pendingCount: pendingMessages.length
-	};
-}
-function withExecutionUpdate(conversation, execution, nowMs) {
-	return {
-		...conversation,
-		updatedAtMs: nowMs,
-		execution: {
-			...executionWithPendingMessages(execution, execution.pendingMessages),
-			updatedAtMs: nowMs
-		}
-	};
-}
-async function getConnectedState(stateAdapter) {
-	const state = stateAdapter ?? getStateAdapter();
-	await state.connect();
-	return state;
-}
-async function sleep(ms) {
-	await new Promise((resolve) => {
-		setTimeout(resolve, ms).unref?.();
-	});
-}
-async function withIndexLock(state, indexKey, callback) {
-	const startedAtMs = now$1();
-	let lock;
-	while (true) {
-		lock = await state.acquireLock(indexLockKey(indexKey), CONVERSATION_INDEX_LOCK_TTL_MS);
-		if (lock) break;
-		if (now$1() - startedAtMs >= CONVERSATION_INDEX_LOCK_WAIT_MS) throw new Error(`Could not acquire conversation index lock for ${indexKey}`);
-		await sleep(CONVERSATION_INDEX_LOCK_RETRY_MS);
-	}
-	try {
-		return await callback();
-	} finally {
-		await state.releaseLock(lock);
-	}
-}
-function normalizeIndexEntry(value) {
-	if (!isRecord$1(value)) return;
-	const conversationId = toOptionalString(value.conversationId);
-	const score = toOptionalNumber(value.score);
-	if (!conversationId || typeof score !== "number") return;
-	return {
-		conversationId,
-		score
-	};
-}
-function uniqueIndexEntries(value) {
-	if (!Array.isArray(value)) return [];
-	const entries = /* @__PURE__ */ new Map();
-	for (const item of value) {
-		const entry = normalizeIndexEntry(item);
-		if (!entry) continue;
-		const existing = entries.get(entry.conversationId);
-		if (!existing || entry.score > existing.score) entries.set(entry.conversationId, entry);
-	}
-	return [...entries.values()];
-}
-function retainedIndexEntries(indexKey, entries) {
-	if (indexKey === CONVERSATION_BY_ACTIVITY_INDEX_KEY) return entries.sort(compareIndexDescending).slice(0, CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH);
-	if (indexKey === CONVERSATION_ACTIVE_INDEX_KEY) return entries.sort(compareIndexAscending);
-	throw new Error(`Unknown conversation index ${indexKey}`);
-}
-function redisIndexKey(indexKey) {
-	const prefix = getChatConfig().state.keyPrefix;
-	return [...prefix ? [prefix] : [], indexKey].join(":");
-}
-function parseRedisIndexEntries(values) {
-	if (!Array.isArray(values)) return [];
-	const entries = [];
-	for (let index = 0; index < values.length; index += 2) {
-		const conversationId = toOptionalString(values[index]);
-		const score = typeof values[index + 1] === "number" ? values[index + 1] : Number(values[index + 1]);
-		if (!conversationId || !Number.isFinite(score)) continue;
-		entries.push({
-			conversationId,
-			score
-		});
-	}
-	return entries;
-}
-function redisConversationIndexStore(client) {
-	const upsertBoundedActivityScript = `
-    redis.call("ZADD", KEYS[1], ARGV[1], ARGV[2])
-    redis.call("PEXPIRE", KEYS[1], ARGV[3])
-    local extra = redis.call("ZCARD", KEYS[1]) - tonumber(ARGV[4])
-    if extra > 0 then
-      redis.call("ZREMRANGEBYRANK", KEYS[1], 0, extra - 1)
-    end
-    return 1
-  `;
-	return {
-		async list(args) {
-			const key = redisIndexKey(args.indexKey);
-			const limit = args.limit;
-			const offset = Math.max(0, args.offset ?? 0);
-			if (limit === 0) return [];
-			return parseRedisIndexEntries(args.scoreMax !== void 0 ? await client.sendCommand([
-				"ZRANGEBYSCORE",
-				key,
-				"-inf",
-				String(args.scoreMax),
-				"WITHSCORES",
-				...limit !== void 0 || offset > 0 ? [
-					"LIMIT",
-					String(offset),
-					String(limit ?? 1e9)
-				] : []
-			]) : await client.sendCommand([
-				args.order === "asc" ? "ZRANGE" : "ZREVRANGE",
-				key,
-				String(offset),
-				String(limit === void 0 ? -1 : offset + Math.max(0, limit - 1)),
-				"WITHSCORES"
-			]));
-		},
-		async remove(args) {
-			await client.sendCommand([
-				"ZREM",
-				redisIndexKey(args.indexKey),
-				args.conversationId
-			]);
-		},
-		async upsert(args) {
-			const key = redisIndexKey(args.indexKey);
-			if (args.indexKey === CONVERSATION_BY_ACTIVITY_INDEX_KEY) {
-				await client.sendCommand([
-					"EVAL",
-					upsertBoundedActivityScript,
-					"1",
-					key,
-					String(args.score),
-					args.conversationId,
-					String(JUNIOR_THREAD_STATE_TTL_MS),
-					String(CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH)
-				]);
-				return;
-			}
-			if (args.indexKey === CONVERSATION_ACTIVE_INDEX_KEY) {
-				await client.sendCommand([
-					"ZADD",
-					key,
-					String(args.score),
-					args.conversationId
-				]);
-				await client.sendCommand([
-					"PEXPIRE",
-					key,
-					String(JUNIOR_THREAD_STATE_TTL_MS)
-				]);
-				return;
-			}
-			throw new Error(`Unknown conversation index ${args.indexKey}`);
-		}
-	};
-}
-function emulatedConversationIndexStore(state) {
-	const readIndex = async (indexKey) => uniqueIndexEntries(await state.get(indexKey));
-	const writeIndex = async (indexKey, entries) => {
-		await state.set(indexKey, entries, JUNIOR_THREAD_STATE_TTL_MS);
-	};
-	return {
-		async list(args) {
-			const entries = (await readIndex(args.indexKey)).filter((entry) => args.scoreMax === void 0 ? true : entry.score <= args.scoreMax).sort(args.order === "asc" ? compareIndexAscending : compareIndexDescending);
-			const offset = Math.max(0, args.offset ?? 0);
-			return entries.slice(offset, args.limit === void 0 ? entries.length : offset + args.limit);
-		},
-		async remove(args) {
-			await withIndexLock(state, args.indexKey, async () => {
-				const entries = await readIndex(args.indexKey);
-				const next = entries.filter((entry) => entry.conversationId !== args.conversationId);
-				if (next.length === entries.length) return;
-				await writeIndex(args.indexKey, next);
-			});
-		},
-		async upsert(args) {
-			await withIndexLock(state, args.indexKey, async () => {
-				const withoutCurrent = (await readIndex(args.indexKey)).filter((entry) => entry.conversationId !== args.conversationId);
-				const next = retainedIndexEntries(args.indexKey, [...withoutCurrent, {
-					conversationId: args.conversationId,
-					score: args.score
-				}]);
-				await writeIndex(args.indexKey, next);
-			});
-		}
-	};
-}
-async function getConversationIndexStore(state) {
-	const redisStateAdapter = await getDefaultRedisStateAdapterFor(state);
-	if (redisStateAdapter) return redisConversationIndexStore(redisStateAdapter.getClient());
-	return emulatedConversationIndexStore(state);
-}
-async function upsertIndexEntry(args) {
-	await (await getConversationIndexStore(args.state)).upsert({
-		conversationId: args.conversationId,
-		indexKey: args.indexKey,
-		score: args.score
-	});
-}
-async function removeIndexEntry(args) {
-	await (await getConversationIndexStore(args.state)).remove({
-		conversationId: args.conversationId,
-		indexKey: args.indexKey
-	});
-}
-async function acquireMutationLock(state, conversationId) {
-	const startedAtMs = now$1();
-	while (true) {
-		const lock = await state.acquireLock(mutationLockKey(conversationId), CONVERSATION_MUTATION_LOCK_TTL_MS);
-		if (lock) return lock;
-		if (now$1() - startedAtMs >= CONVERSATION_MUTATION_WAIT_MS) throw new Error(`Could not acquire conversation mutation lock for ${conversationId}`);
-		await sleep(CONVERSATION_MUTATION_RETRY_MS);
-	}
-}
-async function withConversationMutation(args, callback) {
-	const state = await getConnectedState(args.state);
-	const lock = await acquireMutationLock(state, args.conversationId);
-	try {
-		return await callback(state, lock);
-	} finally {
-		await state.releaseLock(lock);
-	}
-}
-async function readConversation(state, conversationId) {
-	const raw = await state.get(conversationKey(conversationId));
-	if (raw == null) return;
-	const conversation = normalizeConversation(conversationId, raw);
-	if (!conversation) throw new InvalidConversationRecordError(conversationId);
-	return conversation;
-}
-/**
-* Persist a conversation and refresh its reporting and active-recovery indexes.
-*
-* Conversation writes are lock-serialized blind whole-record writes, so the
-* mutation lock is re-validated (and extended) immediately before the write:
-* a stalled mutator that lost its lock must fail loudly instead of clobbering
-* a newer record with a stale copy.
-*/
-async function writeConversation(state, lock, conversation) {
-	const execution = executionWithPendingMessages(conversation.execution, conversation.execution.pendingMessages);
-	const next = {
-		...conversation,
-		execution
-	};
-	await fenceConversationMutation(state, lock, next.conversationId);
-	const hasSlackDestination = next.destination?.platform === "slack";
-	const stored = {
-		...next,
-		execution: {
-			...next.execution,
-			pendingMessages: next.execution.pendingMessages.map((message) => storeMessage(message, hasSlackDestination && (message.source === "slack" || message.source === "event" || message.source === "plugin" || message.source === "scheduler")))
-		}
-	};
-	await state.set(conversationKey(next.conversationId), stored, JUNIOR_THREAD_STATE_TTL_MS);
-	await upsertIndexEntry({
-		state,
-		indexKey: CONVERSATION_BY_ACTIVITY_INDEX_KEY,
-		conversationId: next.conversationId,
-		score: next.lastActivityAtMs
-	});
-	if (!hasRunnableWork(next)) {
-		await removeIndexEntry({
-			state,
-			indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
-			conversationId: next.conversationId
-		});
-		return;
-	}
-	await upsertIndexEntry({
-		state,
-		indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
-		conversationId: next.conversationId,
-		score: next.execution.updatedAtMs ?? next.updatedAtMs
-	});
-}
-function assertSameOptionalConversationDestination(args) {
-	if (!args.next || !args.current) return;
-	if (sameDestination(args.current, args.next)) return;
-	throw new Error(`Conversation destination changed for ${args.conversationId}`);
-}
-function conversationWorkState(conversation) {
-	const lease = conversation.execution.lease;
-	return {
-		...conversation,
-		lastEnqueuedAtMs: conversation.execution.lastEnqueuedAtMs,
-		...lease ? { lease: {
-			acquiredAtMs: lease.acquiredAtMs,
-			lastCheckInAtMs: lease.lastCheckInAtMs,
-			leaseExpiresAtMs: lease.expiresAtMs,
-			leaseToken: lease.token
-		} } : void 0,
-		messages: pendingMessages(conversation),
-		needsRun: hasRunnableWork(conversation)
-	};
-}
-/** Return a persisted conversation record, if one exists. */
-async function getConversation$1(args) {
-	return await readConversation(await getConnectedState(args.state), args.conversationId);
-}
-/** Return a persisted conversation work record, if one exists. */
-async function getConversationWorkState$1(args) {
-	const conversation = await getConversation$1(args);
-	return conversation ? conversationWorkState(conversation) : void 0;
-}
-/** Return whether a conversation has pending or resumable execution work. */
-function hasRunnableConversationWork$1(conversation) {
-	return hasRunnableWork(conversation);
-}
-async function appendInboundMessageWithAdmission(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation({
-		conversationId: args.message.conversationId,
-		state: args.state
-	}, async (state, lock) => {
-		const existing = await readConversation(state, args.message.conversationId);
-		const current = existing ?? emptyConversation({
-			conversationId: args.message.conversationId,
-			destination: args.message.destination,
-			nowMs,
-			source: args.message.source
-		});
-		if (existing) assertSameOptionalConversationDestination({
-			conversationId: args.message.conversationId,
-			current: current.destination,
-			next: args.message.destination
-		});
-		const existingPending = current.execution.pendingMessages.some((message) => message.inboundMessageId === args.message.inboundMessageId);
-		if (current.execution.inboundMessageIds.includes(args.message.inboundMessageId)) {
-			if (!existingPending) return { status: "duplicate" };
-			const nextStatus = current.execution.status === "idle" ? "pending" : current.execution.status;
-			await writeConversation(state, lock, withExecutionUpdate(current, {
-				...current.execution,
-				status: nextStatus,
-				pendingMessages: current.execution.pendingMessages.map((message) => message.inboundMessageId === args.message.inboundMessageId ? upgradedPendingMessage(message, args.message) : message)
-			}, nowMs));
-			return { status: "duplicate" };
-		}
-		if (args.exclusive && hasRunnableWork(current)) return { status: "active" };
-		let status;
-		if (current.execution.lease) status = current.execution.status === "running" ? "running" : "paused";
-		else if (current.execution.status === "paused" && args.message.delivery === "defer") status = "paused";
-		else status = "pending";
-		await writeConversation(state, lock, withExecutionUpdate({
-			...current,
-			destination: current.destination ?? args.message.destination,
-			source: current.source ?? args.message.source,
-			lastActivityAtMs: nowMs
-		}, {
-			...current.execution,
-			status,
-			inboundMessageIds: [...current.execution.inboundMessageIds, args.message.inboundMessageId],
-			pendingMessages: [...current.execution.pendingMessages, args.message].sort(compareMessages)
-		}, nowMs));
-		return { status: "appended" };
-	});
-}
-/** Persist one inbound message idempotently in its conversation mailbox. */
-async function appendInboundMessage(args) {
-	const result = await appendInboundMessageWithAdmission({
-		...args,
-		exclusive: false
-	});
-	if (result.status === "active") throw new Error("Non-exclusive mailbox append returned active");
-	return result;
-}
-/** Append only when the Conversation has no other runnable work. */
-async function appendExclusiveInboundMessage(args) {
-	return await appendInboundMessageWithAdmission({
-		...args,
-		exclusive: true
-	});
-}
-/** Mark a conversation runnable when there is no new mailbox message. */
-async function requestConversationWork$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const existing = await readConversation(state, args.conversationId);
-		if (existing) assertSameOptionalConversationDestination({
-			conversationId: args.conversationId,
-			current: existing.destination,
-			next: args.destination
-		});
-		const current = existing ?? emptyConversation({
-			conversationId: args.conversationId,
-			destination: args.destination,
-			nowMs
-		});
-		const status = current.execution.lease ? "paused" : "pending";
-		await writeConversation(state, lock, withExecutionUpdate({
-			...current,
-			destination: current.destination ?? args.destination
-		}, {
-			...current.execution,
-			status
-		}, nowMs));
-		return { status: existing === void 0 ? "created" : "updated" };
-	});
-}
-/** Record that a wake-up nudge was accepted for the conversation. */
-async function markConversationWorkEnqueued$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current) return;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lastEnqueuedAtMs: nowMs
-		}, nowMs));
-	});
-}
-/** Clear a wake marker after its queue delivery finds no runnable work. */
-async function clearConsumedConversationWake$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || hasRunnableWork(current) || current.execution.lastEnqueuedAtMs === void 0) return false;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lastEnqueuedAtMs: void 0
-		}, nowMs));
-		return true;
-	});
-}
-/** Try to acquire the durable execution lease for one conversation. */
-async function startConversationWork$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current) return { status: "no_work" };
-		if (isLeaseActive(current.execution.lease, nowMs)) return {
-			status: "active",
-			leaseExpiresAtMs: current.execution.lease.expiresAtMs
-		};
-		if (!hasRunnableWork(current)) return { status: "no_work" };
-		const lease = {
-			token: randomUUID(),
-			acquiredAtMs: nowMs,
-			lastCheckInAtMs: nowMs,
-			expiresAtMs: nowMs + CONVERSATION_WORK_LEASE_TTL_MS
-		};
-		const startsNewRun = current.execution.runId === void 0;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lease,
-			status: current.execution.status === "paused" ? "paused" : "running",
-			runId: current.execution.runId ?? randomUUID(),
-			lastEnqueuedAtMs: void 0,
-			retryCount: startsNewRun ? 0 : current.execution.retryCount
-		}, nowMs));
-		return {
-			status: "acquired",
-			leaseToken: lease.token,
-			leaseExpiresAtMs: lease.expiresAtMs
-		};
-	});
-}
-/** Extend the durable execution lease when the worker checks in. */
-async function checkInConversationWork$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken) return false;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lease: {
-				...current.execution.lease,
-				lastCheckInAtMs: nowMs,
-				expiresAtMs: nowMs + CONVERSATION_WORK_LEASE_TTL_MS
-			}
-		}, nowMs));
-		return true;
-	});
-}
-/**
-* Resolve pending mailbox entries after the caller accepts responsibility.
-*
-* Returning ids acknowledges only that subset; returning nothing acknowledges
-* every pending entry passed to the handler.
-*/
-async function drainConversationMailbox$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	const pending = await withConversationMutation(args, async (state) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken) throw new Error(`Conversation lease is not held for ${args.conversationId}`);
-		return pendingMessages(current);
-	});
-	if (pending.length === 0) return {
-		changed: false,
-		messages: []
-	};
-	const result = await args.handle(pending);
-	const pendingIds = new Set(pending.map((message) => message.inboundMessageId));
-	const acknowledgedIds = new Set(result ?? pending.map((message) => message.inboundMessageId));
-	for (const inboundMessageId of acknowledgedIds) if (!pendingIds.has(inboundMessageId)) throw new Error(`Conversation mailbox drain result is not pending for ${args.conversationId}`);
-	if (acknowledgedIds.size === 0) return {
-		changed: false,
-		messages: []
-	};
-	await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken) throw new Error(`Conversation lease is not held for ${args.conversationId}`);
-		const pendingMessages = current.execution.pendingMessages.filter((message) => !acknowledgedIds.has(message.inboundMessageId));
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			status: current.execution.status === "pending" && pendingMessages.length === 0 ? "running" : current.execution.status,
-			lastProgressAtMs: nowMs,
-			retryCount: 0,
-			pendingMessages
-		}, nowMs));
-	});
-	return {
-		changed: true,
-		messages: pending.filter((message) => acknowledgedIds.has(message.inboundMessageId))
-	};
-}
-/** Acknowledge leased mailbox entries after the handler accepts responsibility. */
-async function ackMessages$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	const inboundMessageIds = new Set(args.inboundMessageIds);
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken) return false;
-		if (inboundMessageIds.size === 0) return true;
-		const pendingMessages = current.execution.pendingMessages.filter((message) => !inboundMessageIds.has(message.inboundMessageId));
-		if (pendingMessages.length === current.execution.pendingMessages.length) return true;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lastProgressAtMs: nowMs,
-			retryCount: 0,
-			pendingMessages
-		}, nowMs));
-		return true;
-	});
-}
-function isHumanFacingMessage(message) {
-	return message.source === "web" || message.source === "slack";
-}
-async function readConversationStop(state, conversationId) {
-	return normalizeStop(await state.get(conversationStopKey(conversationId)));
-}
-async function fenceConversationMutation(state, lock, conversationId) {
-	if (!await state.extendLock(lock, CONVERSATION_MUTATION_LOCK_TTL_MS)) throw new ConversationMutationFencedError(conversationId);
-}
-/** Return whether one Conversation run has a durable stop request. */
-async function hasConversationStop(args) {
-	return (await readConversationStop(await getConnectedState(args.state), args.conversationId))?.runId === args.runId;
-}
-/** Persist a stop request for the current run without process affinity. */
-async function stopConversationWork$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || !hasRunnableWork(current)) return { status: "no_work" };
-		const runId = current.execution.runId ?? randomUUID();
-		const inboundMessageIds = current.execution.pendingMessages.filter(isHumanFacingMessage).map((message) => message.inboundMessageId);
-		if (current.execution.runId === void 0) await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			runId
-		}, nowMs));
-		await fenceConversationMutation(state, lock, args.conversationId);
-		await state.set(conversationStopKey(args.conversationId), {
-			inboundMessageIds,
-			runId
-		}, JUNIOR_THREAD_STATE_TTL_MS);
-		return {
-			runId,
-			status: "requested"
-		};
-	});
-}
-/** Clear one observed stop request and discard older human-facing mailbox work. */
-async function completeConversationStop$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken) return {
-			status: "lost_lease",
-			removedInboundMessageIds: []
-		};
-		const stop = await readConversationStop(state, args.conversationId);
-		if (!stop || stop.runId !== args.runId) return {
-			status: "none",
-			removedInboundMessageIds: []
-		};
-		const stoppedInboundMessageIds = new Set(stop.inboundMessageIds);
-		const removedInboundMessageIds = [];
-		const pendingMessages = current.execution.pendingMessages.filter((message) => {
-			const shouldStop = stoppedInboundMessageIds.has(message.inboundMessageId);
-			if (shouldStop) removedInboundMessageIds.push(message.inboundMessageId);
-			return !shouldStop;
-		});
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lastEnqueuedAtMs: pendingMessages.length === 0 ? void 0 : current.execution.lastEnqueuedAtMs,
-			pendingMessages
-		}, nowMs));
-		await fenceConversationMutation(state, lock, args.conversationId);
-		await state.delete(conversationStopKey(args.conversationId));
-		return {
-			status: "cleared",
-			removedInboundMessageIds
-		};
-	});
-}
-/** Cancel human-facing pending mailbox rows without requiring a worker lease. */
-async function cancelHumanFacingPendingMessages$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	const requestedIds = args.inboundMessageIds === void 0 ? void 0 : new Set(args.inboundMessageIds);
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current) return { cancelledInboundMessageIds: [] };
-		const cancelledInboundMessageIds = [];
-		const pendingMessages = [];
-		for (const message of current.execution.pendingMessages) {
-			const isRequested = requestedIds === void 0 || requestedIds.has(message.inboundMessageId);
-			const isInSnapshot = args.receivedBeforeMs === void 0 || message.receivedAtMs <= args.receivedBeforeMs;
-			if (isHumanFacingMessage(message) && isRequested && isInSnapshot) {
-				cancelledInboundMessageIds.push(message.inboundMessageId);
-				continue;
-			}
-			pendingMessages.push(message);
-		}
-		if (cancelledInboundMessageIds.length === 0) return { cancelledInboundMessageIds };
-		const becomesIdle = current.execution.status === "pending" && pendingMessages.length === 0;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lastEnqueuedAtMs: pendingMessages.length === 0 ? void 0 : current.execution.lastEnqueuedAtMs,
-			pendingMessages,
-			retryCount: becomesIdle ? 0 : current.execution.retryCount,
-			runId: becomesIdle ? void 0 : current.execution.runId,
-			status: becomesIdle ? "idle" : current.execution.status
-		}, nowMs));
-		return { cancelledInboundMessageIds };
-	});
-}
-/** Mark the leased conversation as needing another queue-delivered slice. */
-async function requestAnotherSlice$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken) return false;
-		assertSameOptionalConversationDestination({
-			conversationId: args.conversationId,
-			current: current.destination,
-			next: args.destination
-		});
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			status: "paused"
-		}, nowMs));
-		return true;
-	});
-}
-/** Begin a requested turn resume under the worker's existing lease. */
-async function beginConversationResume$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken || current.execution.status !== "paused") return false;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			status: "running"
-		}, nowMs));
-		return true;
-	});
-}
-/** Release the durable execution lease without changing completion state. */
-async function releaseConversationWork$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken) return false;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lease: void 0,
-			status: current.execution.status === "running" ? "pending" : current.execution.status
-		}, nowMs));
-		return true;
-	});
-}
-/** Count one failed execution attempt and stop the conversation when retries are exhausted. */
-async function recordConversationRetry$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken) return "lost_lease";
-		const count = (current.execution.retryCount ?? 0) + 1;
-		const stopped = count >= 5;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lastEnqueuedAtMs: void 0,
-			lease: stopped ? void 0 : current.execution.lease,
-			retryCount: count,
-			pendingMessages: stopped ? [] : current.execution.pendingMessages,
-			runId: stopped ? void 0 : current.execution.runId,
-			status: stopped ? "failed" : "paused"
-		}, nowMs));
-		return stopped ? "stopped" : "recorded";
-	});
-}
-/** Finish a leased conversation and report whether runnable work remains. */
-async function completeConversationWork$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken) return "lost_lease";
-		const hasPending = pendingMessages(current).length > 0;
-		const stopped = args.resumeIfStopped === true && (await readConversationStop(state, args.conversationId))?.runId === current.execution.runId;
-		const needsRun = current.execution.status === "paused" || stopped;
-		const runnable = needsRun || hasPending;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lease: void 0,
-			status: needsRun ? "paused" : hasPending ? "pending" : "idle",
-			lastProgressAtMs: args.madeProgress === false ? current.execution.lastProgressAtMs : nowMs,
-			retryCount: runnable || args.madeProgress === false ? current.execution.retryCount : 0,
-			runId: runnable ? current.execution.runId : void 0
-		}, nowMs));
-		return runnable ? "pending" : "completed";
-	});
-}
-/**
-* Record one failed execution attempt for pending messages, dead-lettering
-* the conversation when its retry budget or the legacy message delivery limit
-* is exhausted.
-*
-* Retries are counted only when the run made no durable progress: if any
-* attempted message left the mailbox, the remaining pending entries may be
-* deliberate deferrals and are left untouched. Consumed message ids stay in
-* `inboundMessageIds` so source retries remain duplicates.
-*/
-async function recordAttemptFailure$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken) return {
-			status: "lost_lease",
-			pendingCount: 0,
-			deadLetteredMessages: [],
-			retryCount: 0
-		};
-		const pendingIds = new Set(current.execution.pendingMessages.map((message) => message.inboundMessageId));
-		if (args.inboundMessageIds.length === 0 || args.inboundMessageIds.some((id) => !pendingIds.has(id))) return {
-			status: "skipped",
-			pendingCount: current.execution.pendingMessages.length,
-			deadLetteredMessages: [],
-			retryCount: current.execution.retryCount ?? 0
-		};
-		const retryCount = (current.execution.retryCount ?? 0) + 1;
-		const retriesExhausted = retryCount >= 5;
-		const attemptedIds = new Set(args.inboundMessageIds);
-		const deadLetteredMessages = [];
-		const pendingMessages = [];
-		for (const message of current.execution.pendingMessages) {
-			if (!attemptedIds.has(message.inboundMessageId)) {
-				if (retriesExhausted) deadLetteredMessages.push(message);
-				else pendingMessages.push(message);
-				continue;
-			}
-			const attempted = {
-				...message,
-				attemptCount: (message.attemptCount ?? 0) + 1
-			};
-			if (retriesExhausted || attempted.attemptCount >= 5) {
-				deadLetteredMessages.push(attempted);
-				continue;
-			}
-			pendingMessages.push(attempted);
-		}
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			retryCount,
-			pendingMessages
-		}, nowMs));
-		return {
-			status: "recorded",
-			pendingCount: pendingMessages.length,
-			deadLetteredMessages,
-			retryCount
-		};
-	});
-}
-/** Record a terminal failure completion for a leased conversation. */
-async function deadLetterAttempt$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current || current.execution.lease?.token !== args.leaseToken) return "lost_lease";
-		const runnable = pendingMessages(current).length > 0;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lease: void 0,
-			status: runnable ? "pending" : "failed",
-			runId: runnable ? current.execution.runId : void 0
-		}, nowMs));
-		return runnable ? "pending" : "failed";
-	});
-}
-/** Recover an expired lease, consuming the retry budget under the mutation lock. */
-async function clearExpiredConversationLease$1(args) {
-	const nowMs = args.nowMs ?? now$1();
-	return await withConversationMutation(args, async (state, lock) => {
-		const current = await readConversation(state, args.conversationId);
-		if (!current?.execution.lease || current.execution.lease.expiresAtMs > nowMs) return "not_expired";
-		const retryCount = (current.execution.retryCount ?? 0) + 1;
-		const stopped = retryCount >= 5;
-		await writeConversation(state, lock, withExecutionUpdate(current, {
-			...current.execution,
-			lastEnqueuedAtMs: void 0,
-			lease: void 0,
-			retryCount,
-			pendingMessages: stopped ? [] : current.execution.pendingMessages,
-			runId: stopped ? void 0 : current.execution.runId,
-			status: stopped ? "failed" : "paused"
-		}, nowMs));
-		return stopped ? "stopped" : "requeued";
-	});
-}
-/** Remove one conversation from the active index after it is missing or idle. */
-async function removeActiveConversation$1(args) {
-	await removeIndexEntry({
-		state: await getConnectedState(args.state),
-		indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
-		conversationId: args.conversationId
-	});
-}
-/** List active conversation ids by oldest execution update first. */
-async function listActiveConversationIds$1(args = {}) {
-	return (await (await getConversationIndexStore(await getConnectedState(args.state))).list({
-		indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
-		limit: args.limit,
-		order: "asc",
-		scoreMax: args.staleBeforeMs
-	})).map((entry) => entry.conversationId);
-}
-//#endregion
-//#region src/chat/task-execution/store.ts
-function metadataStore(options) {
-	return options.conversationStore ?? getConversationStore();
-}
-function duplicateInboundNudgeIdempotencyKey(message, nowMs) {
-	return `duplicate:${message.conversationId}:${message.inboundMessageId}:${nowMs}`;
-}
-function hasRecentEnqueueMarker(conversation, nowMs) {
-	const lastEnqueuedAtMs = conversation.execution.lastEnqueuedAtMs;
-	return typeof lastEnqueuedAtMs === "number" && lastEnqueuedAtMs + 6e4 > nowMs;
-}
-function now() {
-	return Date.now();
-}
-async function recordExecutionMetadata(args) {
-	const conversation = await getConversation$1({
-		conversationId: args.conversationId,
-		state: args.state
-	});
-	if (!conversation) return;
-	await metadataStore(args).recordExecution({
-		channelName: conversation.channelName,
-		conversationId: conversation.conversationId,
-		createdAtMs: conversation.createdAtMs,
-		destination: conversation.destination,
-		execution: {
-			lastCheckpointAtMs: conversation.execution.lastCheckpointAtMs,
-			lastEnqueuedAtMs: conversation.execution.lastEnqueuedAtMs,
-			runId: conversation.execution.runId,
-			status: conversation.execution.status,
-			updatedAtMs: conversation.execution.updatedAtMs
-		},
-		lastActivityAtMs: conversation.lastActivityAtMs,
-		metrics: null,
-		actor: conversation.actor,
-		source: conversation.source,
-		title: conversation.title,
-		updatedAtMs: conversation.updatedAtMs
-	});
-}
-/** Return a persisted conversation record, if one exists. */
-async function getConversation(args) {
-	return await getConversation$1(args);
-}
-/** Return a persisted conversation work record, if one exists. */
-async function getConversationWorkState(args) {
-	return await getConversationWorkState$1(args);
-}
-/** Count one failed conversation execution and persist its terminal retry state. */
-async function recordConversationRetry(args) {
-	const result = await recordConversationRetry$1(args);
-	await recordExecutionMetadata(args);
-	return result;
-}
-/** Count mailbox messages that have not yet reached the conversation event log. */
-function countPendingConversationMessages(conversation) {
-	return conversation.execution.pendingMessages.length;
-}
-/** Return whether a conversation has pending or resumable execution work. */
-function hasRunnableConversationWork(conversation) {
-	return conversation.execution.status !== "idle" || countPendingConversationMessages(conversation) > 0;
-}
-/**
-* Ensure runnable conversation work has one accepted queue wake-up nudge.
-*
-* Ordinary wakes coalesce on a recent accepted marker. A caller can ignore the
-* marker without replacing an active lease. Replacement is only for consumed
-* or known-stale deliveries where another queue nudge must exist.
-*/
-async function ensureConversationWake(args) {
-	const nowMs = args.nowMs ?? now();
-	const conversation = await getConversation$1({
-		conversationId: args.conversationId,
-		state: args.state
-	});
-	if (!conversation || !hasRunnableConversationWork(conversation)) return { status: "no_work" };
-	if (args.replaceExistingWake !== true && conversation.execution.lease && conversation.execution.lease.expiresAtMs > nowMs) return { status: "lease_active" };
-	if (args.ignoreEnqueueMarker !== true && args.replaceExistingWake !== true && hasRecentEnqueueMarker(conversation, nowMs)) return { status: "already_enqueued" };
-	const queueResult = await args.queue.send({
-		schemaVersion: 2,
-		conversationId: args.conversationId
-	}, {
-		delayMs: args.delayMs,
-		idempotencyKey: args.idempotencyKey
-	});
-	await markConversationWorkEnqueued({
-		conversationId: args.conversationId,
-		conversationStore: args.conversationStore,
-		nowMs,
-		state: args.state
-	});
-	return {
-		status: "enqueued",
-		queueMessageId: queueResult?.messageId
-	};
-}
-async function enqueueAfterAppend(args) {
-	const nowMs = args.nowMs ?? now();
-	const appendResult = args.appendResult;
-	if (appendResult.status === "active") return appendResult;
-	let idempotencyKey = args.message.inboundMessageId;
-	if (appendResult.status === "duplicate") {
-		const conversation = await getConversation$1({
-			conversationId: args.message.conversationId,
-			state: args.state
-		});
-		if (!conversation) return appendResult;
-		if (hasRecentEnqueueMarker(conversation, nowMs)) {
-			await recordExecutionMetadata({
-				conversationId: args.message.conversationId,
-				conversationStore: args.conversationStore,
-				state: args.state
-			});
-			return appendResult;
-		}
-		if (!conversation.execution.pendingMessages.some((message) => message.inboundMessageId === args.message.inboundMessageId)) {
-			await recordExecutionMetadata({
-				conversationId: args.message.conversationId,
-				conversationStore: args.conversationStore,
-				state: args.state
-			});
-			return appendResult;
-		}
-		idempotencyKey = duplicateInboundNudgeIdempotencyKey(args.message, nowMs);
-	}
-	const wake = await ensureConversationWake({
-		conversationId: args.message.conversationId,
-		conversationStore: args.conversationStore,
-		delayMs: args.queueDelayMs,
-		idempotencyKey,
-		ignoreEnqueueMarker: args.message.source === "event" ? void 0 : true,
-		nowMs,
-		queue: args.queue,
-		replaceExistingWake: args.replaceExistingWake,
-		state: args.state
-	});
-	if (wake.status !== "enqueued") await recordExecutionMetadata({
-		conversationId: args.message.conversationId,
-		conversationStore: args.conversationStore,
-		state: args.state
-	});
-	return {
-		...appendResult,
-		...wake.status === "enqueued" ? { queueMessageId: wake.queueMessageId } : void 0
-	};
-}
-/** Persist inbound work and ensure a worker wake-up. */
-async function appendAndEnqueueInboundMessage(args) {
-	const nowMs = args.nowMs ?? now();
-	const result = await enqueueAfterAppend({
-		...args,
-		appendResult: await appendInboundMessage({
-			message: args.message,
-			nowMs,
-			state: args.state
-		}),
-		nowMs
-	});
-	if (result.status === "active") throw new Error("Non-exclusive mailbox enqueue returned active");
-	return result;
-}
-/** Persist exclusive inbound work and wake its worker when admitted. */
-async function appendAndEnqueueExclusiveInboundMessage(args) {
-	const nowMs = args.nowMs ?? now();
-	return await enqueueAfterAppend({
-		...args,
-		appendResult: await appendExclusiveInboundMessage({
-			message: args.message,
-			nowMs,
-			state: args.state
-		}),
-		nowMs
-	});
-}
-/** Persist a stop request for the current Conversation run. */
-async function stopConversationWork(args) {
-	const result = await stopConversationWork$1(args);
-	if (result.status === "requested") await recordExecutionMetadata(args);
-	return result;
-}
-/** Finish an observed stop request under the current worker lease. */
-async function completeConversationStop(args) {
-	const result = await completeConversationStop$1(args);
-	if (result.status === "cleared") await recordExecutionMetadata(args);
-	return result;
-}
-/** Clear an accepted wake marker after its delivery finds no runnable work. */
-async function clearConsumedConversationWake(args) {
-	const result = await clearConsumedConversationWake$1(args);
-	if (result) await recordExecutionMetadata(args);
-	return result;
-}
-/** Mark a conversation runnable when there is no new mailbox message. */
-async function requestConversationWork(args) {
-	const result = await requestConversationWork$1(args);
-	await recordExecutionMetadata({
-		conversationId: args.conversationId,
-		conversationStore: args.conversationStore,
-		state: args.state
-	});
-	return result;
-}
-/** Record that a wake-up nudge was accepted for the conversation. */
-async function markConversationWorkEnqueued(args) {
-	await markConversationWorkEnqueued$1(args);
-	await recordExecutionMetadata(args);
-}
-/** Try to acquire the durable execution lease for one conversation. */
-async function startConversationWork(args) {
-	const result = await startConversationWork$1(args);
-	await recordExecutionMetadata(args);
-	return result;
-}
-/** Extend the durable execution lease when the worker checks in. */
-async function checkInConversationWork(args) {
-	const result = await checkInConversationWork$1(args);
-	if (result) await recordExecutionMetadata(args);
-	return result;
-}
-/** Drain pending mailbox entries after the caller accepts responsibility. */
-async function drainConversationMailbox(args) {
-	const result = await drainConversationMailbox$1(args);
-	if (result.changed) await recordExecutionMetadata(args);
-	return result.messages;
-}
-/** Acknowledge leased mailbox entries after the handler accepts responsibility. */
-async function ackMessages(args) {
-	const result = await ackMessages$1(args);
-	await recordExecutionMetadata(args);
-	return result;
-}
-/** Cancel human-facing pending mailbox rows without requiring a worker lease. */
-async function cancelHumanFacingPendingMessages(args) {
-	const result = await cancelHumanFacingPendingMessages$1(args);
-	if (result.cancelledInboundMessageIds.length > 0) await recordExecutionMetadata(args);
-	return result;
-}
-/** Mark the leased conversation as needing another queue-delivered slice. */
-async function requestAnotherSlice(args) {
-	const result = await requestAnotherSlice$1(args);
-	await recordExecutionMetadata(args);
-	return result;
-}
-/** Begin a requested turn resume without releasing the current lease. */
-async function beginConversationResume(args) {
-	const result = await beginConversationResume$1(args);
-	if (result) await recordExecutionMetadata(args);
-	return result;
-}
-/** Release the durable execution lease without changing completion state. */
-async function releaseConversationWork(args) {
-	const result = await releaseConversationWork$1(args);
-	await recordExecutionMetadata(args);
-	return result;
-}
-/** Finish a leased conversation and report whether runnable work remains. */
-async function completeConversationWork(args) {
-	const result = await completeConversationWork$1(args);
-	await recordExecutionMetadata(args);
-	return result;
-}
-/** Record one failed delivery attempt and dead-letter messages at their limit. */
-async function recordAttemptFailure(args) {
-	const result = await recordAttemptFailure$1(args);
-	if (result.status === "recorded") await recordExecutionMetadata(args);
-	return result;
-}
-/** Record a terminal failure completion for a leased conversation. */
-async function deadLetterAttempt(args) {
-	const result = await deadLetterAttempt$1(args);
-	await recordExecutionMetadata(args);
-	return result;
-}
-/** Recover an expired lease and persist the resulting retry state. */
-async function clearExpiredConversationLease(args) {
-	const result = await clearExpiredConversationLease$1(args);
-	await recordExecutionMetadata(args);
-	return result;
-}
-/** Remove one conversation from the active index after it is missing or idle. */
-async function removeActiveConversation(args) {
-	return await removeActiveConversation$1(args);
-}
-/** List active conversation ids by oldest execution update first. */
-async function listActiveConversationIds(args = {}) {
-	return await listActiveConversationIds$1(args);
-}
-//#endregion
-//#region src/chat/events/catalog.ts
-/** Core-owned event namespace. Not a plugin publisher. */
-const CORE_EVENT_NAMESPACE = "junior";
-/** True when the catalog has any enabled registration. */
-function hasEventCatalogEntries(catalog) {
-	return Object.keys(catalog).length > 0;
-}
-/**
-* True when at least one plugin namespace is enabled.
-*
-* Core Workspace snapshot events stay in the catalog for search and temporary
-* watches. Durable event automations still require a plugin publisher.
-*/
-function hasPluginEventCatalogEntries(catalog) {
-	return Object.keys(pluginEventCatalog(catalog)).length > 0;
-}
-/**
-* Catalog entries that durable event automations may select.
-*
-* Core Workspace snapshot events only wake temporary watches. Snapshot finish
-* does not run event-automation ingest, so those namespaces stay out of create/update
-* schemas and trigger availability.
-*/
-function pluginEventCatalog(catalog) {
-	return Object.fromEntries(Object.entries(catalog).filter(([namespace]) => namespace !== CORE_EVENT_NAMESPACE));
-}
-function enumSchema(values, unavailableMessage) {
-	if (values.length === 0) return z.string().refine(() => false, unavailableMessage);
-	return z.enum(values);
-}
-/** Build the model-facing namespace enum from enabled event plugins. */
-function eventNamespaceSchema(catalog) {
-	return enumSchema(Object.keys(catalog).sort(), "No event namespaces are enabled.");
-}
-/** Build the model-facing event enum from enabled plugin registrations. */
-function registeredEventTypeSchema(catalog) {
-	return enumSchema([...new Set(Object.values(catalog).flatMap((registration) => registration.resourceTypes.flatMap((resourceType) => resourceType.supportedEvents)))].sort(), "No event types are enabled.");
-}
-/** Build the model-facing resource type enum from enabled plugin registrations. */
-function registeredResourceTypeSchema(catalog) {
-	return enumSchema([...new Set(Object.values(catalog).flatMap((registration) => registration.resourceTypes.map((resourceType) => resourceType.type)))].sort(), "No resource types are enabled.");
-}
-/** Return whether one enabled plugin declared an event type. */
-function pluginSupportsEvent(catalog, namespace, resourceType, eventType) {
-	return catalog[namespace]?.resourceTypes.find((candidate) => candidate.type === resourceType)?.supportedEvents.includes(eventType) ?? false;
-}
-/** Return app guidance for one registered resource type and event type. */
-function eventGuidance(catalog, namespace, resourceType, eventType) {
-	return catalog[namespace]?.resourceTypes.find((candidate) => candidate.type === resourceType)?.guidance?.[eventType];
-}
-/** Return declared match keys for one registered resource type. */
-function eventMatchFields(catalog, namespace, resourceType) {
-	return catalog[namespace]?.resourceTypes.find((candidate) => candidate.type === resourceType)?.matchFields;
-}
-/** Build the match object the tools accept for one resource type. */
-function registeredEventMatchSchema() {
-	return eventMatchSchema.optional().describe("Optional exact values from the resource type matchFields. A single value must equal the event data. A list means the event value may be any one entry. Omit a key to ignore it. Unmatched events are dropped with no agent turn.");
-}
-/** Reject match keys the resource type does not list. */
-function requireSupportedEventMatch(catalog, input) {
-	const match = input.match;
-	if (!match || Object.keys(match).length === 0) return void 0;
-	const fields = eventMatchFields(catalog, input.namespace, input.resourceType);
-	if (!fields || Object.keys(fields).length === 0) throw new ToolInputError(`Resource type "${input.namespace}:${input.resourceType}" does not support match.`);
-	const normalized = {};
-	for (const [key, value] of Object.entries(match)) {
-		const field = fields[key];
-		if (!field) throw new ToolInputError(`Resource type "${input.namespace}:${input.resourceType}" does not support match key "${key}".`);
-		if (Array.isArray(value)) {
-			if (field.kind === "boolean") throw new ToolInputError(`Match key "${key}" is boolean and cannot use a list.`);
-			for (const entry of value) {
-				if (typeof entry !== field.kind) throw new ToolInputError(`Match key "${key}" expects ${field.kind} values.`);
-				if (field.enum && typeof entry === "string" && !field.enum.includes(entry)) throw new ToolInputError(`Match key "${key}" does not allow value "${entry}".`);
-			}
-			normalized[key] = [...new Set(value)];
-			continue;
-		}
-		if (typeof value !== field.kind) throw new ToolInputError(`Match key "${key}" expects a ${field.kind} value.`);
-		if (field.enum && typeof value === "string" && !field.enum.includes(value)) throw new ToolInputError(`Match key "${key}" does not allow value "${value}".`);
-		normalized[key] = value;
-	}
-	return Object.keys(normalized).length > 0 ? normalized : void 0;
-}
-/** Normalize one selector with the convention declared by its plugin. */
-function normalizeCatalogEventIdentifier(catalog, namespace, identifier) {
-	return normalizeEventIdentifier(catalog[namespace], identifier);
-}
-//#endregion
-//#region src/chat/sandbox/snapshot/events.ts
-const WORKSPACE_SNAPSHOT_NAMESPACE = CORE_EVENT_NAMESPACE;
-const WORKSPACE_SNAPSHOT_RESOURCE_TYPE = "workspace_snapshot";
-const WORKSPACE_SNAPSHOT_READY_EVENT = "workspace_snapshot.ready";
-const WORKSPACE_SNAPSHOT_FAILED_EVENT = "workspace_snapshot.failed";
-/**
-* Core catalog entry for Workspace snapshot ready and failed events.
-*
-* Uses the same registration shape as plugins so search, guidance, and tool
-* schemas treat these events like any other resource type.
-*/
-function workspaceSnapshotEvents() {
-	return { resourceTypes: [{
-		type: WORKSPACE_SNAPSHOT_RESOURCE_TYPE,
-		supportedEvents: [WORKSPACE_SNAPSHOT_READY_EVENT, WORKSPACE_SNAPSHOT_FAILED_EVENT],
-		suggestedEvents: [],
-		guidance: {
-			[WORKSPACE_SNAPSHOT_READY_EVENT]: "Call switchWorkspace again with the same Workspace name. Do not create another watch when switchWorkspace already returned a subscription.",
-			[WORKSPACE_SNAPSHOT_FAILED_EVENT]: "Report the snapshot failure. Do not keep waiting for this Workspace unless the user asks to retry."
-		}
-	}] };
-}
-/** Describe the events that report when a snapshot build ends. */
-function workspaceSnapshotWatch(input) {
-	return {
-		identifier: input.workspaceId,
-		label: `Workspace ${input.workspaceName} snapshot`,
-		namespace: WORKSPACE_SNAPSHOT_NAMESPACE,
-		supportedEvents: [WORKSPACE_SNAPSHOT_READY_EVENT, WORKSPACE_SNAPSHOT_FAILED_EVENT],
-		suggestedEvents: [],
-		type: WORKSPACE_SNAPSHOT_RESOURCE_TYPE
-	};
-}
-/** Report that a Workspace snapshot build is ready or failed. */
-function workspaceSnapshotFinishedEvent(input) {
-	const occurredAtMs = input.occurredAtMs ?? Date.now();
-	const eventType = input.status === "ready" ? WORKSPACE_SNAPSHOT_READY_EVENT : WORKSPACE_SNAPSHOT_FAILED_EVENT;
-	const trustedSummary = input.status === "ready" ? "Workspace snapshot is ready." : "Workspace snapshot build failed.";
-	const event = {
-		eventKey: `${WORKSPACE_SNAPSHOT_NAMESPACE}:${input.workspaceId}:${input.resultId}:${input.status}`,
-		eventType,
-		identifier: input.workspaceId,
-		namespace: WORKSPACE_SNAPSHOT_NAMESPACE,
-		occurredAtMs,
-		terminal: true,
-		trustedSummary,
-		data: {
-			workspaceId: input.workspaceId,
-			status: input.status
-		}
-	};
-	if (input.status === "failed" && input.error) event.untrustedText = input.error;
-	return event;
-}
-//#endregion
-//#region src/chat/events/runtime-catalog.ts
-/**
-* Enabled event registrations for search, guidance, and tool schemas.
-*
-* Includes core Workspace snapshot events under the `junior` namespace, plus
-* every enabled plugin registration. Plugins may not use the `junior` namespace.
-*/
-function getEventCatalog() {
-	const catalog = { [CORE_EVENT_NAMESPACE]: workspaceSnapshotEvents() };
-	for (const plugin of getPlugins()) {
-		const registration = plugin.events;
-		if (!registration || registration.isEnabled?.() === false) continue;
-		if (plugin.manifest.name === "junior") throw new Error(`Plugin "${CORE_EVENT_NAMESPACE}" cannot register events; that namespace is reserved for core Workspace snapshots`);
-		catalog[plugin.manifest.name] = registration;
-	}
-	return catalog;
-}
-/** Validate the persisted Slack creator identity for an event automation. */
-const eventAutomationPrincipalSchema = z.object({
-	slackUserId: actorUserIdSchema,
-	fullName: z.string().optional(),
-	userName: z.string().optional()
-}).strict();
-/** Validate one persisted event-automation selector and its presentation metadata. */
-const eventAutomationTriggerSchema = z.object({
-	events: z.array(eventTypeSchema).min(1),
-	label: z.string().min(1),
-	match: eventMatchSchema.optional(),
-	namespace: z.string().min(1),
-	identifier: z.string().min(1).max(300),
-	resourceType: z.string().min(1)
-}).strict();
-/** Event automations target a Slack channel or DM, never a message thread. */
-const eventAutomationDestinationSchema = slackDestinationSchema.omit({ threadTs: true });
-const eventAutomationOutcomeSchema = taskOutcomeSchema.extend({ destination: eventAutomationDestinationSchema });
-/** Validate one persisted event automation. */
-const eventAutomationSchema = z.object({
-	id: z.string().min(1),
-	createdAtMs: z.number().finite(),
-	createdBy: eventAutomationPrincipalSchema,
-	credentialMode: z.enum(["system", "creator"]),
-	destination: eventAutomationDestinationSchema,
-	destinationVisibility: destinationVisibilitySchema,
-	/** Explicit visible effects after successful work. An empty list is silent. */
-	outcomes: z.array(eventAutomationOutcomeSchema).max(5),
-	task: z.object({ text: z.string().min(1) }).strict(),
-	trigger: eventAutomationTriggerSchema
-}).strict();
-//#endregion
-//#region src/chat/event-automations/store.ts
-const retainedEventAutomationSchema = eventAutomationSchema.extend({
-	destination: slackDestinationSchema,
-	outcomes: z.array(taskOutcomeSchema).max(5)
-});
-/** JSON task payload must not carry SQL-backed columns. */
-function eventAutomationJsonPayload(task) {
-	const { status: _status, title: _title, ...payload } = task;
-	return payload;
-}
-function parseTask(row) {
-	const raw = row.task && typeof row.task === "object" ? { ...row.task } : row.task;
-	if (raw && typeof raw === "object" && "title" in raw) delete raw.title;
-	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 === "deleted" ? "deleted" : "active",
-		...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({
-		status: juniorEventAutomations.status,
-		task: juniorEventAutomations.task,
-		title: juniorEventAutomations.title
-	}).from(juniorEventAutomations).where(eq(juniorEventAutomations.id, id)).limit(1);
-	return rows[0] ? parseTask(rows[0]) : void 0;
-}
-/** Create one retry-stable event automation, or revive a deleted row with the new payload. */
-async function createEventAutomation(db, task) {
-	const parsed = eventAutomationSchema.parse(eventAutomationJsonPayload(task));
-	const title = task.title?.trim() || null;
-	await db.insert(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();
-	const existing = await getEventAutomation(db, parsed.id);
-	if (!existing) return {
-		...parsed,
-		status: "active",
-		...title ? { title } : void 0
-	};
-	if (existing.status !== "deleted") return existing;
-	const rows = await db.update(juniorEventAutomations).set({
-		teamId: parsed.destination.teamId,
-		namespace: parsed.trigger.namespace,
-		identifier: parsed.trigger.identifier,
-		status: "active",
-		title,
-		task: parsed
-	}).where(and(eq(juniorEventAutomations.id, parsed.id), eq(juniorEventAutomations.status, "deleted"))).returning({
-		status: juniorEventAutomations.status,
-		task: juniorEventAutomations.task,
-		title: juniorEventAutomations.title
-	});
-	return rows[0] ? parseTask(rows[0]) : await getEventAutomation(db, parsed.id) ?? {
-		...parsed,
-		status: "active",
-		...title ? { title } : void 0
-	};
-}
-/** Replace an existing non-deleted event automation. */
-async function saveEventAutomation(db, task) {
-	const parsed = eventAutomationSchema.parse(eventAutomationJsonPayload(task));
-	const title = task.title?.trim() || null;
-	const rows = await db.update(juniorEventAutomations).set({
-		namespace: parsed.trigger.namespace,
-		identifier: parsed.trigger.identifier,
-		title,
-		task: parsed
-	}).where(and(eq(juniorEventAutomations.id, parsed.id), activeEventAutomationWhere())).returning({
-		status: juniorEventAutomations.status,
-		task: juniorEventAutomations.task,
-		title: juniorEventAutomations.title
-	});
-	return rows[0] ? parseTask(rows[0]) : void 0;
-}
-/** Mark one existing event automation deleted while retaining the row for history. */
-async function deleteEventAutomation(db, id) {
-	const rows = await db.update(juniorEventAutomations).set({ status: "deleted" }).where(and(eq(juniorEventAutomations.id, id), activeEventAutomationWhere())).returning({
-		status: juniorEventAutomations.status,
-		task: juniorEventAutomations.task,
-		title: juniorEventAutomations.title
-	});
-	return rows[0] ? parseTask(rows[0]) : void 0;
-}
-/** List live event automations in one Slack workspace. */
-async function listEventAutomationsForTeam(db, teamId) {
-	return (await db.select({
-		status: juniorEventAutomations.status,
-		task: juniorEventAutomations.task,
-		title: juniorEventAutomations.title
-	}).from(juniorEventAutomations).where(and(eq(juniorEventAutomations.teamId, teamId), activeEventAutomationWhere())).orderBy(asc(juniorEventAutomations.createdAtMs), asc(juniorEventAutomations.id))).map(parseTask);
-}
-function viewerSlackIdentities(user) {
-	return user.identities.filter((identity) => identity.provider === "slack" && Boolean(identity.providerTenantId) && Boolean(identity.providerSubjectId));
-}
-/** Return whether one event automation was created by a viewer-linked Slack identity. */
-function eventAutomationBelongsToUser(task, user) {
-	return viewerSlackIdentities(user).some((identity) => identity.providerTenantId === task.destination.teamId && identity.providerSubjectId === task.createdBy.slackUserId);
-}
-/** List a bounded newest-first page of live event automations created by one user. */
-async function listEventAutomationsCreatedBy(db, user, limit, query) {
-	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({
-		status: juniorEventAutomations.status,
-		task: juniorEventAutomations.task,
-		title: juniorEventAutomations.title
-	}).from(juniorEventAutomations).where(and(ownership, activeEventAutomationWhere(), query ? sql`strpos(lower(coalesce(${juniorEventAutomations.title}, ${juniorEventAutomations.task}->'task'->>'text')), ${query}) > 0` : void 0)).orderBy(desc(juniorEventAutomations.createdAtMs), desc(juniorEventAutomations.id)).limit(limit)).map(parseTask);
-}
-/**
-* List deleted event 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({
-		status: juniorEventAutomations.status,
-		task: juniorEventAutomations.task,
-		title: juniorEventAutomations.title
-	}).from(juniorEventAutomations).where(and(ownership, eq(juniorEventAutomations.status, "deleted"))).orderBy(desc(juniorEventAutomations.createdAtMs), desc(juniorEventAutomations.id)).limit(limit)).map(parseTask);
-}
-/** List live event automations whose current Slack destination is public. */
-async function listPublicEventAutomationsForTeams(db, teamIds, limit, query) {
-	if (teamIds.length === 0) return [];
-	return (await db.select({
-		status: juniorEventAutomations.status,
-		task: juniorEventAutomations.task,
-		title: juniorEventAutomations.title
-	}).from(juniorEventAutomations).innerJoin(juniorDestinations, and(eq(juniorDestinations.provider, "slack"), eq(juniorDestinations.providerTenantId, juniorEventAutomations.teamId), sql`${juniorDestinations.providerDestinationId} = ${juniorEventAutomations.task}->'destination'->>'channelId'`)).where(and(inArray(juniorEventAutomations.teamId, teamIds), activeEventAutomationWhere(), query ? sql`strpos(lower(coalesce(${juniorEventAutomations.title}, ${juniorEventAutomations.task}->'task'->>'text')), ${query}) > 0` : void 0, eq(juniorDestinations.visibility, "public"))).orderBy(desc(juniorEventAutomations.createdAtMs), desc(juniorEventAutomations.id)).limit(limit)).map(parseTask);
-}
-/**
-* Collect match keys from live event 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({
-		status: juniorEventAutomations.status,
-		task: juniorEventAutomations.task,
-		title: juniorEventAutomations.title
-	}).from(juniorEventAutomations).where(and(eq(juniorEventAutomations.teamId, input.teamId), eq(juniorEventAutomations.namespace, input.namespace), inArray(juniorEventAutomations.identifier, identifiers), activeEventAutomationWhere())).orderBy(asc(juniorEventAutomations.createdAtMs), asc(juniorEventAutomations.id));
-	const keys = /* @__PURE__ */ new Set();
-	for (const row of rows) {
-		const task = parseTask(row);
-		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({
-		status: juniorEventAutomations.status,
-		task: juniorEventAutomations.task,
-		title: juniorEventAutomations.title
-	}).from(juniorEventAutomations).where(and(eq(juniorEventAutomations.teamId, teamId), eq(juniorEventAutomations.namespace, event.namespace), eq(juniorEventAutomations.identifier, event.identifier), activeEventAutomationWhere())).orderBy(asc(juniorEventAutomations.createdAtMs), asc(juniorEventAutomations.id))).map(parseTask).filter((task) => task.trigger.events.includes(event.eventType) && eventMatches(task.trigger.match, event.data));
-}
-//#endregion
-//#region src/chat/task-outcomes.ts
-const taskMessageDestinationInputSchema = z.enum(["current_conversation", "task_creator"]).describe("Where to send the message. Use current_conversation for posts, digests, summaries, and channel reminders. Use task_creator only when the user asks for a direct reminder or notification.");
-/** Input accepted by task authoring tools before a user becomes a DM Destination. */
-const taskOutcomeInputSchema = z.object({
-	action: z.literal("send_message"),
-	destination: taskMessageDestinationInputSchema
-}).strict();
-/** Resolve explicit message outcomes to the Slack Destinations stored on an Automation. */
-async function resolveTaskOutcomes(outcomes, currentDestination, creatorSlackUserId) {
-	if (outcomes === void 0) return [];
-	const resolved = [];
-	for (const outcome of outcomes) {
-		if (outcome.destination === "current_conversation") {
-			resolved.push({
-				action: "send_message",
-				destination: currentDestination
-			});
-			continue;
-		}
-		const userId = creatorSlackUserId;
-		const channelId = (await withSlackRetries(() => getSlackClient().conversations.open({ users: userId }), 3, { action: "conversations.open" })).channel?.id;
-		if (!channelId) throw new Error("Slack did not return a direct message destination.");
-		resolved.push({
-			action: "send_message",
-			destination: {
-				platform: "slack",
-				teamId: currentDestination.teamId,
-				channelId
-			}
-		});
-	}
-	return resolved;
-}
-function outcomeTargetsDestination(outcome, destination) {
-	return outcome.destination.teamId === destination.teamId && outcome.destination.channelId === destination.channelId && (!outcome.destination.threadTs || outcome.destination.threadTs === destination.threadTs);
-}
-/** Bind same-channel message outcomes to the Automation Destination. */
-function effectiveTaskOutcomes(outcomes, destination) {
-	return outcomes.map((outcome) => destination.threadTs && outcomeTargetsDestination(outcome, destination) ? {
-		...outcome,
-		destination
-	} : outcome);
-}
-/** Move outcomes that target the task Destination and keep other outcomes unchanged. */
-function moveTaskOutcomes(outcomes, currentDestination, nextDestination) {
-	return effectiveTaskOutcomes(outcomes, currentDestination).map((outcome) => outcomeTargetsDestination(outcome, currentDestination) ? {
-		...outcome,
-		destination: nextDestination
-	} : outcome);
-}
-//#endregion
-//#region src/chat/event-automations/tool-support.ts
-const compactEventAutomationResultSchema = z.object({
-	id: z.string().min(1),
-	title: z.string().min(1).nullable(),
-	dashboardUrl: z.string().url().nullable(),
-	instruction: z.string().min(1),
-	trigger: z.object({
-		namespace: z.string().min(1),
-		identifier: z.string().min(1),
-		resourceType: z.string().min(1),
-		label: z.string().min(1),
-		events: z.array(z.string().min(1)).min(1),
-		match: z.record(z.string(), z.unknown()).optional(),
-		available: z.boolean()
-	}).strict(),
-	credentialMode: z.enum(["system", "creator"]),
-	isCreator: z.boolean(),
-	outcomes: z.array(z.object({
-		action: z.literal("send_message"),
-		destination: z.object({
-			channel: z.string().min(1),
-			thread: z.string().min(1).nullable()
-		}).strict()
-	}).strict()).max(5),
-	createdBy: z.object({
-		name: z.string().min(1).nullable(),
-		username: z.string().min(1).nullable()
-	}).strict()
-}).strict();
-/** Validate one successful event-automation mutation result. */
-const eventAutomationToolResultSchema = juniorToolOutputSchema.extend({
-	automation: compactEventAutomationResultSchema,
-	objectCards: z.array(ownedObjectAnnotationSchema)
-}).strict();
-/** Validate one successful event-automation list result. */
-const eventAutomationListToolResultSchema = juniorToolOutputSchema.extend({
-	automations: z.array(compactEventAutomationResultSchema),
-	truncated: z.boolean()
-}).strict();
-/** Build the validated event trigger accepted by event-automation tools. */
-function registeredEventAutomationTriggerSchema(catalog) {
-	const plugins = pluginEventCatalog(catalog);
-	return z.object({
-		namespace: eventNamespaceSchema(plugins),
-		identifier: z.string().trim().min(1).max(300),
-		resourceType: registeredResourceTypeSchema(plugins),
-		label: z.string().trim().min(1).max(500),
-		events: z.array(registeredEventTypeSchema(plugins)).min(1),
-		match: registeredEventMatchSchema()
-	}).strict();
-}
-/** Reject an event-automation trigger that is no longer supported by the catalog. */
-function requireSupportedEventAutomationTrigger(catalog, trigger) {
-	const plugins = pluginEventCatalog(catalog);
-	for (const eventType of trigger.events) if (!pluginSupportsEvent(plugins, trigger.namespace, trigger.resourceType, eventType)) throw new ToolInputError(`Resource type "${trigger.namespace}:${trigger.resourceType}" does not support event "${eventType}".`);
-	return requireSupportedEventMatch(plugins, {
-		match: trigger.match,
-		namespace: trigger.namespace,
-		resourceType: trigger.resourceType
-	});
-}
-/** Require the active Slack authority used for event-automation management. */
-function requireEventAutomationSlackContext(context) {
-	if (context.source.kind !== "slack" || context.destination.platform !== "slack" || context.actor?.platform !== "slack" || context.actor.teamId !== context.source.teamId) throw new ToolInputError("Event automations require an active Slack channel or DM and actor.");
-	return {
-		actor: context.actor,
-		destination: {
-			platform: "slack",
-			teamId: context.source.teamId,
-			channelId: context.source.channelId
-		},
-		source: context.source
-	};
-}
-/** Return whether an event automation belongs to the active Slack destination. */
-function eventAutomationMatchesDestination(task, destination) {
-	return task.destination.teamId === destination.teamId && task.destination.channelId === destination.channelId;
-}
-/**
-* Return whether the active destination may update or delete this automation.
-* Same-destination automations stay local. Public automations may be managed by id from
-* another destination in the same workspace.
-*/
-function eventAutomationIsWritableFrom(task, destination) {
-	if (task.destination.teamId !== destination.teamId) return false;
-	return task.destination.channelId === destination.channelId || task.destinationVisibility === "public";
-}
-/** Load one automation the active destination may update or delete. */
-async function writableEventAutomation(context, id) {
-	const { destination } = requireEventAutomationSlackContext(context);
-	const task = await getEventAutomation(getDb(), id);
-	if (!task || task.status === "deleted" || !eventAutomationIsWritableFrom(task, destination)) throw new ToolInputError("Event automation was not found.");
-	return task;
-}
-function eventAutomationTriggerAvailable(task, catalog) {
-	const registration = pluginEventCatalog(catalog)[task.trigger.namespace];
-	return Boolean(registration && task.trigger.events.every((eventType) => registration.resourceTypes.some((resourceType) => resourceType.supportedEvents.includes(eventType))));
-}
-/** Project an event automation into the bounded tool-result shape. */
-function compactEventAutomation(task, catalog, requesterSlackUserId) {
-	return compactEventAutomationResultSchema.parse({
-		id: task.id,
-		title: task.title?.trim() || null,
-		dashboardUrl: getDashboardTaskLink(task.id) ?? null,
-		instruction: task.task.text,
-		trigger: {
-			namespace: task.trigger.namespace,
-			identifier: task.trigger.identifier,
-			resourceType: task.trigger.resourceType,
-			label: task.trigger.label,
-			events: task.trigger.events,
-			...task.trigger.match ? { match: task.trigger.match } : void 0,
-			available: eventAutomationTriggerAvailable(task, catalog)
-		},
-		credentialMode: task.credentialMode,
-		isCreator: task.createdBy.slackUserId === requesterSlackUserId,
-		outcomes: effectiveTaskOutcomes(task.outcomes, task.destination).map((outcome) => ({
-			action: outcome.action,
-			destination: {
-				channel: outcome.destination.channelId,
-				thread: outcome.destination.threadTs ?? null
-			}
-		})),
-		createdBy: {
-			name: task.createdBy.fullName ?? null,
-			username: task.createdBy.userName ?? null
-		}
-	});
-}
-/** Return the standard successful event-automation tool result. */
-async function eventAutomationToolResult(conversationId, task, catalog, requesterSlackUserId) {
-	const automation = compactEventAutomation(task, catalog, requesterSlackUserId);
-	const filters = Object.entries(task.trigger.match ?? {}).map(([key, value]) => `${key} = ${JSON.stringify(value)}`);
-	const title = automation.title ?? fallbackShortTitle(task.task.text, "Event automation");
-	return {
-		automation,
-		objectCards: await saveObjectAnnotations(conversationId, "junior", [{
-			kind: "object",
-			objectType: "automation",
-			label: title,
-			key: task.id,
-			title,
-			url: automation.dashboardUrl,
-			description: task.task.text,
-			trigger: [
-				task.trigger.label,
-				task.trigger.events.join(", "),
-				...filters
-			].join(" · "),
-			warning: !automation.trigger.available ? "Trigger unavailable. This automation cannot receive events." : void 0
-		}])
-	};
-}
-//#endregion
-//#region src/chat/scheduled-automations/types.ts
-/** Durable scheduled-automation domain types owned by Junior core. */
-const scheduledAutomationStatusSchema = z.enum([
-	"active",
-	"blocked",
-	"completed",
-	"deleted"
-]);
-const scheduledAutomationCredentialModeSchema = z.enum(["system", "creator"]);
-const scheduledRunStatusSchema = z.enum([
-	"pending",
-	"running",
-	"completed",
-	"failed",
-	"blocked",
-	"skipped"
-]);
-const scheduledAutomationPrincipalSchema = z.object({
-	slackUserId: actorUserIdSchema,
-	fullName: z.string().optional(),
-	userName: z.string().optional()
-}).strict();
-const scheduledAutomationRecurrenceSchema = z.object({
-	dayOfMonth: z.number().optional(),
-	frequency: z.enum([
-		"daily",
-		"weekly",
-		"monthly",
-		"yearly"
-	]),
-	interval: z.number(),
-	month: z.number().optional(),
-	startDate: z.string(),
-	time: z.object({
-		hour: z.number(),
-		minute: z.number()
-	}).strict(),
-	weekdays: z.array(z.number()).optional()
-}).strict();
-const scheduledAutomationScheduleSchema = z.object({
-	description: z.string(),
-	kind: z.enum(["one_off", "recurring"]),
-	recurrence: scheduledAutomationRecurrenceSchema.optional(),
-	timezone: z.string()
-}).strict();
-const scheduledAutomationExecutionActorSchema = z.object({
-	platform: z.literal("system"),
-	name: z.string()
-}).strict();
-/** Scheduled automations target a Slack conversation, never one message thread. */
-const scheduledAutomationDestinationSchema = slackDestinationSchema.omit({ threadTs: true });
-const scheduledAutomationOutcomeSchema = z.object({
-	action: z.literal("send_message"),
-	destination: scheduledAutomationDestinationSchema
-}).strict();
-/** Validate the current scheduled-automation domain shape. */
-const scheduledAutomationSchema = z.object({
-	id: z.string(),
-	conversationAccess: z.object({
-		audience: z.enum([
-			"direct",
-			"group",
-			"channel"
-		]),
-		visibility: z.enum(["private", "public"])
-	}).strict(),
-	createdAtMs: z.number(),
-	createdBy: scheduledAutomationPrincipalSchema,
-	/** Authoritative provider identity that created the task. */
-	creatorIdentityId: z.string(),
-	/** Selects system credentials or task-bound creator credential delegation. */
-	credentialMode: scheduledAutomationCredentialModeSchema,
-	destination: scheduledAutomationDestinationSchema,
-	executionActor: scheduledAutomationExecutionActorSchema.optional(),
-	lastRunAtMs: z.number().optional(),
-	nextRunAtMs: z.number().optional(),
-	originalRequest: z.string().optional(),
-	runNowAtMs: z.number().optional(),
-	schedule: scheduledAutomationScheduleSchema,
-	status: scheduledAutomationStatusSchema,
-	statusReason: z.string().optional(),
-	/** Explicit visible effects after successful work. An empty list is silent. */
-	outcomes: z.array(scheduledAutomationOutcomeSchema).max(5),
-	task: z.object({ text: z.string() }).strict(),
-	/** SQL-backed short display title generated from the task instruction. */
-	title: z.string().optional(),
-	updatedAtMs: z.number()
-}).strict();
-/** Validate the current scheduled-run domain shape. */
-const scheduledRunSchema = z.object({
-	id: z.string(),
-	attempt: z.number(),
-	claimedAtMs: z.number(),
-	completedAtMs: z.number().optional(),
-	dispatchId: z.string().optional(),
-	errorMessage: z.string().optional(),
-	resultMessageTs: z.string().optional(),
-	scheduledForMs: z.number(),
-	startedAtMs: z.number().optional(),
-	status: scheduledRunStatusSchema,
-	taskId: z.string()
-}).strict();
-const SCHEDULED_AUTOMATION_SYSTEM_ACTOR = Object.freeze({
-	platform: "system",
-	name: "scheduled-automation"
-});
-//#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),
-	status: z.enum([
-		"active",
-		"blocked",
-		"completed",
-		"deleted",
-		"paused"
-	]),
-	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;
-	if (status === "paused") {
-		const { nextRunAtMs: _nextRunAtMs, runNowAtMs: _runNowAtMs, ...retained } = task;
-		return {
-			...retained,
-			creatorIdentityId,
-			status: "deleted",
-			...title ? { title } : 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", "paused"]), 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) {
-	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);
-}
-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. */
-async function saveScheduledAutomation(db, task) {
-	const next = requireStoredTask(task);
-	await withScheduledAutomationLock(db, task.id, async (tx) => {
-		const current = await readScheduledAutomation(tx, task.id);
-		await writeScheduledAutomation(tx, next, current);
-	});
-	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);
-}
-/** List scheduled automations whose current Slack destination is public. */
-async function listPublicScheduledAutomationsForTeams(db, teamIds, input) {
-	if (teamIds.length === 0) return [];
-	return (await db.select({
-		creatorIdentityId: juniorSchedulerTasks.creatorIdentityId,
-		record: juniorSchedulerTasks.record,
-		title: juniorSchedulerTasks.title
-	}).from(juniorSchedulerTasks).innerJoin(juniorDestinations, and(eq(juniorDestinations.provider, "slack"), eq(juniorDestinations.providerTenantId, juniorSchedulerTasks.teamId), sql`${juniorDestinations.providerDestinationId} = ${juniorSchedulerTasks.record}->'destination'->>'channelId'`)).where(and(inArray(juniorSchedulerTasks.teamId, teamIds), notInArray(juniorSchedulerTasks.status, [
-		"completed",
-		"deleted",
-		"paused"
-	]), input.query ? sql`strpos(lower(coalesce(${juniorSchedulerTasks.title}, ${juniorSchedulerTasks.record}->'task'->>'text')), ${input.query}) > 0` : void 0, eq(juniorDestinations.visibility, "public"))).orderBy(desc(juniorSchedulerTasks.createdAtMs), desc(juniorSchedulerTasks.id)).limit(input.limit)).map(parseScheduledAutomationRow).filter(isListedScheduledAutomation);
-}
-//#endregion
-//#region src/chat/slack/context.ts
-function toTrimmedSlackString(value) {
-	return toOptionalString(value)?.trim() || void 0;
-}
-const slackMessageEnvelopeSchema = z.object({ raw: z.unknown().optional() });
-const rawSlackMessageSchema = z.object({
-	channel: z.unknown().optional(),
-	message: z.unknown().optional(),
-	team: z.unknown().optional(),
-	team_id: z.unknown().optional(),
-	thread_ts: z.unknown().optional(),
-	ts: z.unknown().optional(),
-	user_team: z.unknown().optional()
-});
-const nestedRawSlackMessageSchema = z.object({ ts: z.unknown().optional() });
-/** Project only the Slack raw fields consumed by runtime thread context. */
-function readSlackRawMessageContext(message) {
-	const envelope = slackMessageEnvelopeSchema.safeParse(message);
-	if (!envelope.success) return;
-	const raw = rawSlackMessageSchema.safeParse(envelope.data.raw);
-	if (!raw.success) return;
-	const nestedMessage = nestedRawSlackMessageSchema.safeParse(raw.data.message);
-	const channelId = parseSlackChannelId(raw.data.channel);
-	const threadTs = parseSlackMessageTs(raw.data.thread_ts);
-	const messageTs = parseSlackMessageTs(raw.data.ts);
-	const nestedMessageTs = nestedMessage.success && parseSlackMessageTs(nestedMessage.data.ts);
-	const teamId = parseSlackTeamId(raw.data.team_id) ?? parseSlackTeamId(raw.data.team);
-	const authorTeamId = parseSlackTeamId(raw.data.user_team);
-	return {
-		...channelId ? { channelId } : void 0,
-		...threadTs ? { threadTs } : void 0,
-		...messageTs ? { messageTs } : void 0,
-		...nestedMessageTs ? { nestedMessageTs } : void 0,
-		...teamId ? { teamId } : void 0,
-		...authorTeamId ? { authorTeamId } : void 0
-	};
-}
-/** Extract a channel ID and validated Slack timestamp from `slack:<channel>:<ts>`. */
-function parseSlackThreadId(threadId) {
-	const normalizedThreadId = toTrimmedSlackString(threadId);
-	if (!normalizedThreadId) return;
-	const parts = normalizedThreadId.split(":");
-	if (parts.length !== 3 || parts[0] !== "slack") return;
-	const channelId = parseSlackChannelId(parts[1]);
-	const threadTs = parseSlackMessageTs(parts[2]);
-	if (!channelId || !threadTs) return;
-	return {
-		channelId,
-		threadTs
-	};
-}
-/** Resolve the Slack channel ID from a `slack:<channel>:<ts>` thread identifier. */
-function resolveSlackChannelIdFromThreadId(threadId) {
-	return parseSlackThreadId(threadId)?.channelId;
-}
-/** Best-effort channel ID extraction from a raw Slack message payload. */
-function resolveSlackChannelIdFromMessage(message) {
-	const messageChannelId = parseSlackChannelId(message.channelId);
-	if (messageChannelId) return messageChannelId;
-	const raw = message.raw;
-	if (raw && typeof raw === "object") {
-		const rawChannel = parseSlackChannelId(raw.channel);
-		if (rawChannel) return rawChannel;
-	}
-	return resolveSlackChannelIdFromThreadId(toTrimmedSlackString(message.threadId));
-}
-//#endregion
-//#region src/chat/attachments/store.ts
-const DAY_MS = 864e5;
-const ATTACHMENT_GC_BATCH_LIMIT = 200;
-/** Time that Junior keeps attachment bytes after the file is stored. */
-const ATTACHMENT_RETENTION_MS = 30 * DAY_MS;
-function attachmentDigest(file) {
-	return createHash("sha256").update(file.data).digest("hex");
-}
-/** Stable conversation-owned id for one file body and presentation metadata. */
-function attachmentId(args) {
-	const identity = [
-		args.conversationId,
-		args.storageProvider,
-		args.sha256,
-		args.filename,
-		args.contentType
-	];
-	if (args.source) identity.push(args.source.provider, args.source.id);
-	return createHash("sha256").update(identity.join("\0")).digest("hex");
-}
-/**
-* Object key for one write attempt.
-*
-* Attachment ids are content-stable. Object keys are not: each put gets a fresh
-* key so a failed-write cleanup or GC delete cannot remove another writer's
-* durable blob.
-*/
-function attachmentKey(args) {
-	return `conversations/${args.conversationId}/attachments/${args.attachmentId}/${args.writeId}/${args.filename}`;
-}
-async function bestEffortDelete(storage, key) {
-	try {
-		await storage.delete([key]);
-	} catch {}
-}
-async function isConversationPurged(db, conversationId) {
-	const [row] = await db.db().select({ transcriptPurgedAt: juniorConversations.transcriptPurgedAt }).from(juniorConversations).where(eq(juniorConversations.conversationId, conversationId));
-	return row?.transcriptPurgedAt != null;
-}
-function purgedConversationError(conversationId) {
-	return /* @__PURE__ */ new Error(`Cannot store attachment for purged conversation ${conversationId}`);
-}
-async function assertConversationNotPurged(db, conversationId) {
-	if (await isConversationPurged(db, conversationId)) throw purgedConversationError(conversationId);
-}
-/** Mark a just-written row for deletion and drop its unused object. */
-async function rejectPurgedAttachmentWrite(args) {
-	await args.db.db().update(juniorAttachments).set({ deleteRequestedAt: args.now }).where(eq(juniorAttachments.id, args.id));
-	await bestEffortDelete(args.storage, args.storageKey);
-	throw purgedConversationError(args.conversationId);
-}
-/**
-* Return another writer's live row only when the conversation is still active.
-*
-* The caller already wrote a unique object for this attempt. Delete that unused
-* object either way. If the conversation is purged, do not report success for a
-* row that purge/GC is about to remove.
-*/
-async function reuseLiveAttachment(args) {
-	await bestEffortDelete(args.storage, args.storageKey);
-	await assertConversationNotPurged(args.db, args.conversationId);
-	return { id: args.id };
-}
-/**
-* Persist one conversation-owned file.
-*
-* Identity is content-stable under the conversation. Object storage is written
-* first under a unique key; the SQL row is created only after that write
-* succeeds. A row means the attachment is durable. Retries reuse an existing
-* live row. A purge-marked row is revived by writing a new object and pointing
-* the row at it, unless the conversation is still purged. If the SQL write
-* fails after object storage accepts the bytes, this path deletes that unique
-* object. A process crash between those steps can leave an unreferenced unique
-* object with no SQL row.
-*/
-async function storeAttachment(args) {
-	const now = new Date(args.nowMs ?? Date.now());
-	const sha256 = attachmentDigest(args.file);
-	const id = attachmentId({
-		conversationId: args.conversationId,
-		contentType: args.file.mimeType,
-		filename: args.file.filename,
-		source: args.source,
-		storageProvider: args.storage.provider,
-		sha256
-	});
-	const [existing] = await args.db.db().select({
-		contentType: juniorAttachments.contentType,
-		conversationId: juniorAttachments.conversationId,
-		deleteRequestedAt: juniorAttachments.deleteRequestedAt,
-		filename: juniorAttachments.filename,
-		id: juniorAttachments.id,
-		provider: juniorAttachments.provider,
-		providerId: juniorAttachments.providerId,
-		storageProvider: juniorAttachments.storageProvider,
-		sha256: juniorAttachments.sha256,
-		storageKey: juniorAttachments.storageKey
-	}).from(juniorAttachments).where(eq(juniorAttachments.id, id));
-	if (existing) {
-		if (existing.contentType !== args.file.mimeType || existing.conversationId !== args.conversationId || existing.filename !== args.file.filename || existing.provider !== (args.source?.provider ?? null) || existing.providerId !== (args.source?.id ?? null) || existing.storageProvider !== args.storage.provider || existing.sha256 !== sha256) throw new Error(`Attachment write conflicts with ${existing.id}`);
-		if (existing.deleteRequestedAt === null) {
-			await assertConversationNotPurged(args.db, args.conversationId);
-			return { id: existing.id };
-		}
-	}
-	await assertConversationNotPurged(args.db, args.conversationId);
-	const storageKey = attachmentKey({
-		attachmentId: id,
-		conversationId: args.conversationId,
-		filename: args.file.filename,
-		writeId: randomUUID()
-	});
-	await args.storage.put({
-		body: args.file.data,
-		contentType: args.file.mimeType,
-		key: storageKey
-	});
-	if (existing?.deleteRequestedAt != null) {
-		if (await isConversationPurged(args.db, args.conversationId)) {
-			await bestEffortDelete(args.storage, storageKey);
-			throw purgedConversationError(args.conversationId);
-		}
-		const oldStorageKey = existing.storageKey;
-		if ((await args.db.db().update(juniorAttachments).set({
-			deleteRequestedAt: null,
-			storageKey
-		}).where(and(eq(juniorAttachments.id, id), isNotNull(juniorAttachments.deleteRequestedAt))).returning({ id: juniorAttachments.id })).length > 0) {
-			if (await isConversationPurged(args.db, args.conversationId)) await rejectPurgedAttachmentWrite({
-				conversationId: args.conversationId,
-				db: args.db,
-				id,
-				now,
-				storage: args.storage,
-				storageKey
-			});
-			if (oldStorageKey !== storageKey) await bestEffortDelete(args.storage, oldStorageKey);
-			return { id };
-		}
-		const [afterRace] = await args.db.db().select({
-			deleteRequestedAt: juniorAttachments.deleteRequestedAt,
-			id: juniorAttachments.id,
-			storageKey: juniorAttachments.storageKey
-		}).from(juniorAttachments).where(eq(juniorAttachments.id, id));
-		if (afterRace?.deleteRequestedAt === null) return reuseLiveAttachment({
-			conversationId: args.conversationId,
-			db: args.db,
-			id: afterRace.id,
-			storage: args.storage,
-			storageKey
-		});
-	}
-	let inserted = [];
-	try {
-		inserted = await args.db.db().insert(juniorAttachments).values({
-			id,
-			conversationId: args.conversationId,
-			storageProvider: args.storage.provider,
-			storageKey,
-			provider: args.source?.provider,
-			providerId: args.source?.id,
-			filename: args.file.filename,
-			contentType: args.file.mimeType,
-			bytes: args.file.bytes,
-			sha256,
-			createdAt: now
-		}).onConflictDoNothing({ target: juniorAttachments.id }).returning({ id: juniorAttachments.id });
-	} catch (error) {
-		await bestEffortDelete(args.storage, storageKey);
-		throw error;
-	}
-	if (inserted.length > 0) {
-		if (await isConversationPurged(args.db, args.conversationId)) await rejectPurgedAttachmentWrite({
-			conversationId: args.conversationId,
-			db: args.db,
-			id,
-			now,
-			storage: args.storage,
-			storageKey
-		});
-		return { id };
-	}
-	const [row] = await args.db.db().select({
-		deleteRequestedAt: juniorAttachments.deleteRequestedAt,
-		id: juniorAttachments.id,
-		storageKey: juniorAttachments.storageKey
-	}).from(juniorAttachments).where(eq(juniorAttachments.id, id));
-	if (!row) {
-		await bestEffortDelete(args.storage, storageKey);
-		throw new Error(`Attachment row missing after write for ${id}`);
-	}
-	if (row.deleteRequestedAt === null) return reuseLiveAttachment({
-		conversationId: args.conversationId,
-		db: args.db,
-		id: row.id,
-		storage: args.storage,
-		storageKey
-	});
-	if (await isConversationPurged(args.db, args.conversationId)) {
-		await bestEffortDelete(args.storage, storageKey);
-		throw purgedConversationError(args.conversationId);
-	}
-	if ((await args.db.db().update(juniorAttachments).set({
-		deleteRequestedAt: null,
-		storageKey
-	}).where(and(eq(juniorAttachments.id, id), isNotNull(juniorAttachments.deleteRequestedAt))).returning({ id: juniorAttachments.id })).length > 0) {
-		if (await isConversationPurged(args.db, args.conversationId)) await rejectPurgedAttachmentWrite({
-			conversationId: args.conversationId,
-			db: args.db,
-			id,
-			now,
-			storage: args.storage,
-			storageKey
-		});
-		if (row.storageKey !== storageKey) await bestEffortDelete(args.storage, row.storageKey);
-		return { id };
-	}
-	const [afterRace] = await args.db.db().select({
-		deleteRequestedAt: juniorAttachments.deleteRequestedAt,
-		id: juniorAttachments.id
-	}).from(juniorAttachments).where(eq(juniorAttachments.id, id));
-	if (afterRace?.deleteRequestedAt === null) return reuseLiveAttachment({
-		conversationId: args.conversationId,
-		db: args.db,
-		id: afterRace.id,
-		storage: args.storage,
-		storageKey
-	});
-	await bestEffortDelete(args.storage, storageKey);
-	throw new Error(`Attachment ${id} disappeared while reviving`);
-}
-/** Load one live attachment owned by a conversation. */
-async function readLiveAttachment(args) {
-	const [row] = await args.db.db().select({
-		bytes: juniorAttachments.bytes,
-		contentType: juniorAttachments.contentType,
-		conversationId: juniorAttachments.conversationId,
-		deleteRequestedAt: juniorAttachments.deleteRequestedAt,
-		filename: juniorAttachments.filename,
-		id: juniorAttachments.id,
-		storageProvider: juniorAttachments.storageProvider,
-		storageKey: juniorAttachments.storageKey
-	}).from(juniorAttachments).where(and(eq(juniorAttachments.id, args.attachmentId), eq(juniorAttachments.conversationId, args.conversationId), isNull(juniorAttachments.deleteRequestedAt)));
-	if (!row) return null;
-	if (await isConversationPurged(args.db, args.conversationId)) return null;
-	return {
-		bytes: row.bytes,
-		contentType: row.contentType,
-		conversationId: row.conversationId,
-		filename: row.filename,
-		id: row.id,
-		storageKey: row.storageKey,
-		storageProvider: row.storageProvider
-	};
-}
-/** Persist many conversation-owned files. */
-async function storeAttachments(args) {
-	const stored = [];
-	for (const file of args.files) stored.push(await storeAttachment({
-		conversationId: args.conversationId,
-		db: args.db,
-		file,
-		...args.nowMs !== void 0 ? { nowMs: args.nowMs } : void 0,
-		storage: args.storage
-	}));
-	return stored;
-}
-/** Mark attachments unavailable when their conversation content is purged. */
-async function requestAttachmentDeletion(db, conversationIds, nowMs) {
-	if (conversationIds.length === 0) return;
-	await db.db().update(juniorAttachments).set({ deleteRequestedAt: new Date(nowMs) }).where(and(inArray(juniorAttachments.conversationId, conversationIds), isNull(juniorAttachments.deleteRequestedAt)));
-}
-/**
-* Delete purged attachments in one bounded batch.
-*
-* Eligible rows are 30 days old, explicitly purge-marked, or owned by a
-* conversation whose transcript is already purged. Delete object keys first,
-* then remove rows that are still eligible so a failed blob delete remains
-* retryable.
-*/
-async function collectAttachmentGarbage(args) {
-	const expiresBefore = /* @__PURE__ */ new Date(args.nowMs - ATTACHMENT_RETENTION_MS);
-	const rows = await args.db.db().select({
-		id: juniorAttachments.id,
-		storageKey: juniorAttachments.storageKey
-	}).from(juniorAttachments).innerJoin(juniorConversations, eq(juniorAttachments.conversationId, juniorConversations.conversationId)).where(and(eq(juniorAttachments.storageProvider, args.storage.provider), or(lte(juniorAttachments.createdAt, expiresBefore), isNotNull(juniorAttachments.deleteRequestedAt), isNotNull(juniorConversations.transcriptPurgedAt)))).orderBy(asc(juniorAttachments.createdAt), asc(juniorAttachments.id)).limit(args.limit ?? ATTACHMENT_GC_BATCH_LIMIT);
-	if (rows.length === 0) return { deleted: 0 };
-	await args.storage.delete(rows.map((row) => row.storageKey));
-	const stillEligible = await args.db.db().select({ id: juniorAttachments.id }).from(juniorAttachments).innerJoin(juniorConversations, eq(juniorAttachments.conversationId, juniorConversations.conversationId)).where(and(inArray(juniorAttachments.id, rows.map((row) => row.id)), or(lte(juniorAttachments.createdAt, expiresBefore), isNotNull(juniorAttachments.deleteRequestedAt), isNotNull(juniorConversations.transcriptPurgedAt))));
-	if (stillEligible.length === 0) return { deleted: 0 };
-	return { deleted: (await args.db.db().delete(juniorAttachments).where(inArray(juniorAttachments.id, stillEligible.map((row) => row.id))).returning({ id: juniorAttachments.id })).length };
-}
-//#endregion
-//#region src/stats.ts
-function utcDate(nowMs) {
-	return new Date(nowMs).toISOString().slice(0, 10);
-}
-/** Increment one daily named counter. */
-async function incrementStat(key, options = {}) {
-	const date = utcDate(options.nowMs ?? Date.now());
-	await getDb().insert(juniorStats).values({
-		...key,
-		date,
-		count: 1
-	}).onConflictDoUpdate({
-		target: [
-			juniorStats.date,
-			juniorStats.namespace,
-			juniorStats.metric,
-			juniorStats.name
-		],
-		set: { count: sql`${juniorStats.count} + 1` }
-	});
-}
-/** Read daily counters inside an inclusive UTC date range. */
-async function readStats(start, end) {
-	return await getDb().select().from(juniorStats).where(and(gte(juniorStats.date, start), lte(juniorStats.date, end))).orderBy(asc(juniorStats.date), asc(juniorStats.namespace), asc(juniorStats.metric), asc(juniorStats.name));
-}
-//#endregion
-export { workspaceSnapshotFinishedEvent as $, eventAutomationTriggerAvailable as A, recordConversationRetry as At, createEventAutomation as B, hasRunnableConversationWork$1 as Bt, SCHEDULED_AUTOMATION_SYSTEM_ACTOR as C, drainConversationMailbox as Ct, eventAutomationMatchesDestination as D, hasRunnableConversationWork as Dt, eventAutomationListToolResultSchema as E, getConversationWorkState as Et, effectiveTaskOutcomes as F, startConversationWork as Ft, listDeletedEventAutomationsCreatedBy as G, makeStructuredToolOutput as Gt, eventAutomationBelongsToUser as H, isInvalidConversationRecordError as Ht, moveTaskOutcomes as I, stopConversationWork as It, listPublicEventAutomationsForTeams as J, ToolInputError as Jt, listEventAutomationsCreatedBy as K, buildDeterministicAssistantMessageId as Kt, resolveTaskOutcomes as L, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS as Lt, requireEventAutomationSlackContext as M, removeActiveConversation as Mt, requireSupportedEventAutomationTrigger as N, requestAnotherSlice as Nt, eventAutomationToolResult as O, listActiveConversationIds as Ot, writableEventAutomation as P, requestConversationWork as Pt, WORKSPACE_SNAPSHOT_READY_EVENT as Q, taskOutcomeInputSchema as R, CONVERSATION_WORK_STALE_ENQUEUE_MS as Rt, withScheduledAutomationLock as S, deadLetterAttempt as St, compactEventAutomation as T, getConversation as Tt, findMatchingEventAutomations as U, injectContinuationToolName as Ut, deleteEventAutomation as V, isFinalAttempt as Vt, getEventAutomation as W, juniorToolOutputSchema as Wt, getEventCatalog as X, saveEventAutomation as Y, WORKSPACE_SNAPSHOT_FAILED_EVENT as Z, parseScheduledAutomationRow as _, clearConsumedConversationWake as _t, requestAttachmentDeletion as a, normalizeCatalogEventIdentifier as at, saveScheduledAutomationInLock as b, completeConversationWork as bt, parseSlackThreadId as c, registeredEventTypeSchema as ct, resolveSlackChannelIdFromThreadId as d, ackMessages as dt, workspaceSnapshotWatch as et, createScheduledAutomation as f, appendAndEnqueueExclusiveInboundMessage as ft, listScheduledAutomationsForTeam as g, checkInConversationWork as gt, listScheduledAutomations as h, cancelHumanFacingPendingMessages as ht, readLiveAttachment as i, hasPluginEventCatalogEntries as it, registeredEventAutomationTriggerSchema as j, releaseConversationWork as jt, eventAutomationToolResultSchema as k, recordAttemptFailure as kt, readSlackRawMessageContext as l, registeredResourceTypeSchema as lt, listPublicScheduledAutomationsForTeams as m, beginConversationResume as mt, readStats as n, eventNamespaceSchema as nt, storeAttachment as o, pluginSupportsEvent as ot, isListedScheduledAutomation as p, appendAndEnqueueInboundMessage as pt, listEventAutomationsForTeam as q, buildDeterministicTurnId as qt, collectAttachmentGarbage as r, hasEventCatalogEntries as rt, storeAttachments as s, registeredEventMatchSchema as st, incrementStat as t, eventGuidance as tt, resolveSlackChannelIdFromMessage as u, requireSupportedEventMatch as ut, readScheduledAutomation as v, clearExpiredConversationLease as vt, scheduledRunSchema as w, ensureConversationWake as wt, scheduledRunId as x, countPendingConversationMessages as xt, saveScheduledAutomation as y, completeConversationStop as yt, collectEventAutomationMatchKeys as z, hasConversationStop as zt };