@sentry/junior 0.203.0 → 0.204.0

package/dist/stats-DTUbAb88.js

@@ -0,0 +1,2634 @@
+import { i as getChatConfig } from "./config-nGCW1OTG.js";
+import { F as isRecord$1, I as toOptionalNumber, L as toOptionalString } from "./logging-BzAk1S_s.js";
+import { _ as parseSlackMessageTs, d as parseStoredSlackActor, h as parseSlackTeamId, p as parseSlackChannelId } from "./context-B45_WqVX.js";
+import { B as getSlackClient, Bt as parseDestination, Et as getDb, G as withSlackRetries, Ht as sameDestination, Tt as getConversationStore, u as getPlugins, ut as JUNIOR_THREAD_STATE_TTL_MS } from "./agent-hooks-Bbcp9e33.js";
+import { n as juniorDestinations } from "./destinations-BeBiJeEM.js";
+import { C as juniorConversations, a as juniorSchedulerRuns, c as juniorStats, l as juniorEventTasks, o as juniorSchedulerTasks, x as juniorAttachments } from "./executor-DcMSlI5c.js";
+import { o as ToolInputError } from "./usage-D3EbSO7w.js";
+import { C as getDefaultRedisStateAdapterFor, w as getStateAdapter } from "./profile-CrT5nXbw.js";
+import "./vercel-queue-DIkVcfK4.js";
+import { z } from "zod";
+import { createHash, randomUUID } from "node:crypto";
+import { and, asc, desc, eq, gte, inArray, isNotNull, isNull, lte, ne, notInArray, or, sql } from "drizzle-orm";
+import { actorUserIdSchema, destinationSchema, destinationVisibilitySchema, normalizeResourceEventIdentifier, resourceEventMatchSchema, resourceEventMatches, resourceEventTypeSchema, slackDestinationSchema, taskOutcomeSchema } from "@sentry/junior-plugin-api";
+//#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",
+	"resource_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 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);
+	const normalizedStop = normalizeStop(value.stop);
+	const stop = normalizedStop?.runId === runId ? normalizedStop : void 0;
+	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,
+		stop,
+		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
+	};
+	if (!await state.extendLock(lock, CONVERSATION_MUTATION_LOCK_TTL_MS)) throw new ConversationMutationFencedError(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 === "resource_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";
+}
+/** 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);
+		await writeConversation(state, lock, withExecutionUpdate(current, {
+			...current.execution,
+			runId,
+			stop: {
+				inboundMessageIds,
+				runId
+			}
+		}, nowMs));
+		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 = current.execution.stop;
+		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,
+			stop: void 0
+		}, nowMs));
+		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,
+			stop: becomesIdle ? void 0 : current.execution.stop
+		}, 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",
+			stop: stopped ? void 0 : current.execution.stop
+		}, 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 needsRun = current.execution.status === "paused" || args.resumeIfStopped === true && current.execution.stop !== void 0;
+		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,
+			stop: runnable ? current.execution.stop : 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,
+			stop: runnable ? current.execution.stop : 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",
+			stop: stopped ? void 0 : current.execution.stop
+		}, 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. 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.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,
+		idempotencyKey,
+		nowMs,
+		queue: args.queue,
+		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/resource-events/catalog.ts
+/** Core-owned resource-event namespace. Not a plugin publisher. */
+const CORE_RESOURCE_EVENT_NAMESPACE = "junior";
+/** True when the catalog has any enabled registration. */
+function hasResourceEventCatalogEntries(catalog) {
+	return Object.keys(catalog).length > 0;
+}
+/**
+* True when at least one plugin namespace is enabled.
+*
+* Core Workspace snapshot events stay in the catalog for search and temporary
+* watches. Durable event tasks still require a plugin publisher.
+*/
+function hasPluginResourceEventCatalogEntries(catalog) {
+	return Object.keys(pluginResourceEventCatalog(catalog)).length > 0;
+}
+/**
+* Catalog entries that durable event tasks may select.
+*
+* Core Workspace snapshot events only wake temporary watches. Snapshot finish
+* does not run event-task ingest, so those namespaces stay out of create/update
+* schemas and trigger availability.
+*/
+function pluginResourceEventCatalog(catalog) {
+	return Object.fromEntries(Object.entries(catalog).filter(([namespace]) => namespace !== CORE_RESOURCE_EVENT_NAMESPACE));
+}
+function enumSchema(values, unavailableMessage) {
+	if (values.length === 0) return z.string().refine(() => false, unavailableMessage);
+	return z.enum(values);
+}
+/** Build the model-facing namespace enum from enabled resource event plugins. */
+function eventNamespaceSchema(catalog) {
+	return enumSchema(Object.keys(catalog).sort(), "No resource event namespaces are enabled.");
+}
+/** Build the model-facing event enum from enabled plugin registrations. */
+function registeredEventTypeSchema(catalog) {
+	return enumSchema([...new Set(Object.values(catalog).flatMap((registration) => registration.resourceTypes.flatMap((resourceType) => resourceType.supportedEvents)))].sort(), "No resource event types are enabled.");
+}
+/** 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 resourceEventGuidance(catalog, namespace, resourceType, eventType) {
+	return catalog[namespace]?.resourceTypes.find((candidate) => candidate.type === resourceType)?.guidance?.[eventType];
+}
+/** Return declared match keys for one registered resource type. */
+function resourceEventMatchFields(catalog, namespace, resourceType) {
+	return catalog[namespace]?.resourceTypes.find((candidate) => candidate.type === resourceType)?.matchFields;
+}
+/** Build the match object the tools accept for one resource type. */
+function registeredResourceEventMatchSchema() {
+	return resourceEventMatchSchema.optional().describe("Optional exact values from the resource type matchFields. A single value must equal the event data. A list means the event value may be any one entry. Omit a key to ignore it. Unmatched events are dropped with no agent turn.");
+}
+/** Reject match keys the resource type does not list. */
+function requireSupportedResourceEventMatch(catalog, input) {
+	const match = input.match;
+	if (!match || Object.keys(match).length === 0) return void 0;
+	const fields = resourceEventMatchFields(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 normalizeEventIdentifier(catalog, namespace, identifier) {
+	return normalizeResourceEventIdentifier(catalog[namespace], identifier);
+}
+//#endregion
+//#region src/chat/sandbox/snapshot/events.ts
+const WORKSPACE_SNAPSHOT_NAMESPACE = CORE_RESOURCE_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 workspaceSnapshotResourceEvents() {
+	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/resource-events/runtime-catalog.ts
+/**
+* Enabled resource-event registrations for search, guidance, and tool schemas.
+*
+* Includes core Workspace snapshot events under the `junior` namespace, plus
+* every enabled plugin registration. Plugins may not use the `junior` namespace.
+*/
+function getResourceEventCatalog() {
+	const catalog = { [CORE_RESOURCE_EVENT_NAMESPACE]: workspaceSnapshotResourceEvents() };
+	for (const plugin of getPlugins()) {
+		const registration = plugin.resourceEvents;
+		if (!registration || registration.isEnabled?.() === false) continue;
+		if (plugin.manifest.name === "junior") throw new Error(`Plugin "${CORE_RESOURCE_EVENT_NAMESPACE}" cannot register resource events; that namespace is reserved for core Workspace snapshots`);
+		catalog[plugin.manifest.name] = registration;
+	}
+	return catalog;
+}
+/** Validate the persisted Slack creator identity for an event task. */
+const eventTaskPrincipalSchema = z.object({
+	slackUserId: actorUserIdSchema,
+	fullName: z.string().optional(),
+	userName: z.string().optional()
+}).strict();
+/** Validate one persisted event-task selector and its presentation metadata. */
+const eventTaskTriggerSchema = z.object({
+	events: z.array(resourceEventTypeSchema).min(1),
+	label: z.string().min(1),
+	match: resourceEventMatchSchema.optional(),
+	namespace: z.string().min(1),
+	identifier: z.string().min(1).max(300),
+	resourceType: z.string().min(1)
+}).strict();
+/** Validate one persisted event task. */
+const eventTaskSchema = z.object({
+	id: z.string().min(1),
+	createdAtMs: z.number().finite(),
+	createdBy: eventTaskPrincipalSchema,
+	credentialMode: z.enum(["system", "creator"]),
+	destination: slackDestinationSchema,
+	destinationVisibility: destinationVisibilitySchema,
+	/** Visible effects after successful work. Missing legacy values send a message. */
+	outcomes: z.array(taskOutcomeSchema).max(5).optional(),
+	task: z.object({ text: z.string().min(1) }).strict(),
+	trigger: eventTaskTriggerSchema
+}).strict();
+//#endregion
+//#region src/chat/event-tasks/store.ts
+/** JSON task payload must not carry SQL-backed columns. */
+function eventTaskJsonPayload(task) {
+	const { status: _status, title: _title, ...payload } = task;
+	return payload;
+}
+function parseTask(row) {
+	const raw = row.task && typeof row.task === "object" ? { ...row.task } : row.task;
+	if (raw && typeof raw === "object" && "title" in raw) delete raw.title;
+	const payload = eventTaskSchema.parse(raw);
+	const title = row.title?.trim();
+	return {
+		...payload,
+		status: row.status === "deleted" ? "deleted" : "active",
+		...title ? { title } : void 0
+	};
+}
+function activeEventTaskWhere() {
+	return ne(juniorEventTasks.status, "deleted");
+}
+/** Read one event task by id, including deleted rows when present. */
+async function getEventTask(db, id) {
+	const rows = await db.select({
+		status: juniorEventTasks.status,
+		task: juniorEventTasks.task,
+		title: juniorEventTasks.title
+	}).from(juniorEventTasks).where(eq(juniorEventTasks.id, id)).limit(1);
+	return rows[0] ? parseTask(rows[0]) : void 0;
+}
+/** Create one retry-stable event task, or revive a deleted row with the new payload. */
+async function createEventTask(db, task) {
+	const parsed = eventTaskSchema.parse(eventTaskJsonPayload(task));
+	const title = task.title?.trim() || null;
+	await db.insert(juniorEventTasks).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 getEventTask(db, parsed.id);
+	if (!existing) return {
+		...parsed,
+		status: "active",
+		...title ? { title } : void 0
+	};
+	if (existing.status !== "deleted") return existing;
+	const rows = await db.update(juniorEventTasks).set({
+		teamId: parsed.destination.teamId,
+		namespace: parsed.trigger.namespace,
+		identifier: parsed.trigger.identifier,
+		status: "active",
+		title,
+		task: parsed
+	}).where(and(eq(juniorEventTasks.id, parsed.id), eq(juniorEventTasks.status, "deleted"))).returning({
+		status: juniorEventTasks.status,
+		task: juniorEventTasks.task,
+		title: juniorEventTasks.title
+	});
+	return rows[0] ? parseTask(rows[0]) : await getEventTask(db, parsed.id) ?? {
+		...parsed,
+		status: "active",
+		...title ? { title } : void 0
+	};
+}
+/** Replace an existing non-deleted event task. */
+async function saveEventTask(db, task) {
+	const parsed = eventTaskSchema.parse(eventTaskJsonPayload(task));
+	const title = task.title?.trim() || null;
+	const rows = await db.update(juniorEventTasks).set({
+		namespace: parsed.trigger.namespace,
+		identifier: parsed.trigger.identifier,
+		title,
+		task: parsed
+	}).where(and(eq(juniorEventTasks.id, parsed.id), activeEventTaskWhere())).returning({
+		status: juniorEventTasks.status,
+		task: juniorEventTasks.task,
+		title: juniorEventTasks.title
+	});
+	return rows[0] ? parseTask(rows[0]) : void 0;
+}
+/** Mark one existing event task deleted while retaining the row for history. */
+async function deleteEventTask(db, id) {
+	const rows = await db.update(juniorEventTasks).set({ status: "deleted" }).where(and(eq(juniorEventTasks.id, id), activeEventTaskWhere())).returning({
+		status: juniorEventTasks.status,
+		task: juniorEventTasks.task,
+		title: juniorEventTasks.title
+	});
+	return rows[0] ? parseTask(rows[0]) : void 0;
+}
+/** List live event tasks in one Slack workspace. */
+async function listEventTasksForTeam(db, teamId) {
+	return (await db.select({
+		status: juniorEventTasks.status,
+		task: juniorEventTasks.task,
+		title: juniorEventTasks.title
+	}).from(juniorEventTasks).where(and(eq(juniorEventTasks.teamId, teamId), activeEventTaskWhere())).orderBy(asc(juniorEventTasks.createdAtMs), asc(juniorEventTasks.id))).map(parseTask);
+}
+function viewerSlackIdentities(user) {
+	return user.identities.filter((identity) => identity.provider === "slack" && Boolean(identity.providerTenantId) && Boolean(identity.providerSubjectId));
+}
+/** Return whether one event task was created by a viewer-linked Slack identity. */
+function eventTaskBelongsToUser(task, user) {
+	return viewerSlackIdentities(user).some((identity) => identity.providerTenantId === task.destination.teamId && identity.providerSubjectId === task.createdBy.slackUserId);
+}
+/** List a bounded newest-first page of live event tasks created by one user. */
+async function listEventTasksCreatedBy(db, user, limit, query) {
+	const identities = viewerSlackIdentities(user);
+	const ownership = or(...identities.map((identity) => and(eq(juniorEventTasks.teamId, identity.providerTenantId), sql`${juniorEventTasks.task}->'createdBy'->>'slackUserId' = ${identity.providerSubjectId}`)));
+	if (!ownership) return [];
+	return (await db.select({
+		status: juniorEventTasks.status,
+		task: juniorEventTasks.task,
+		title: juniorEventTasks.title
+	}).from(juniorEventTasks).where(and(ownership, activeEventTaskWhere(), query ? sql`strpos(lower(coalesce(${juniorEventTasks.title}, ${juniorEventTasks.task}->'task'->>'text')), ${query}) > 0` : void 0)).orderBy(desc(juniorEventTasks.createdAtMs), desc(juniorEventTasks.id)).limit(limit)).map(parseTask);
+}
+/**
+* List deleted event tasks created by one user, newest first.
+* Used only to keep historical runs after the live task list drops the row.
+*/
+async function listDeletedEventTasksCreatedBy(db, user, limit) {
+	const identities = viewerSlackIdentities(user);
+	const ownership = or(...identities.map((identity) => and(eq(juniorEventTasks.teamId, identity.providerTenantId), sql`${juniorEventTasks.task}->'createdBy'->>'slackUserId' = ${identity.providerSubjectId}`)));
+	if (!ownership) return [];
+	return (await db.select({
+		status: juniorEventTasks.status,
+		task: juniorEventTasks.task,
+		title: juniorEventTasks.title
+	}).from(juniorEventTasks).where(and(ownership, eq(juniorEventTasks.status, "deleted"))).orderBy(desc(juniorEventTasks.createdAtMs), desc(juniorEventTasks.id)).limit(limit)).map(parseTask);
+}
+/** List live event tasks whose current Slack destination is public. */
+async function listPublicEventTasksForTeams(db, teamIds, limit, query) {
+	if (teamIds.length === 0) return [];
+	return (await db.select({
+		status: juniorEventTasks.status,
+		task: juniorEventTasks.task,
+		title: juniorEventTasks.title
+	}).from(juniorEventTasks).innerJoin(juniorDestinations, and(eq(juniorDestinations.provider, "slack"), eq(juniorDestinations.providerTenantId, juniorEventTasks.teamId), sql`${juniorDestinations.providerDestinationId} = ${juniorEventTasks.task}->'destination'->>'channelId'`)).where(and(inArray(juniorEventTasks.teamId, teamIds), activeEventTaskWhere(), query ? sql`strpos(lower(coalesce(${juniorEventTasks.title}, ${juniorEventTasks.task}->'task'->>'text')), ${query}) > 0` : void 0, eq(juniorDestinations.visibility, "public"))).orderBy(desc(juniorEventTasks.createdAtMs), desc(juniorEventTasks.id)).limit(limit)).map(parseTask);
+}
+/**
+* Collect match keys from live event tasks for these identifiers and event types.
+* Does not evaluate match values — only reports keys that filters use.
+*/
+async function collectEventTaskMatchKeys(db, input) {
+	const eventTypes = new Set(input.eventTypes.map((eventType) => eventType.trim()).filter(Boolean));
+	const identifiers = [...new Set(input.identifiers.map((value) => value.trim()).filter(Boolean))];
+	if (eventTypes.size === 0 || identifiers.length === 0) return [];
+	const rows = await db.select({
+		status: juniorEventTasks.status,
+		task: juniorEventTasks.task,
+		title: juniorEventTasks.title
+	}).from(juniorEventTasks).where(and(eq(juniorEventTasks.teamId, input.teamId), eq(juniorEventTasks.namespace, input.namespace), inArray(juniorEventTasks.identifier, identifiers), activeEventTaskWhere())).orderBy(asc(juniorEventTasks.createdAtMs), asc(juniorEventTasks.id));
+	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 resource event. */
+async function findMatchingEventTasks(db, event, teamId) {
+	return (await db.select({
+		status: juniorEventTasks.status,
+		task: juniorEventTasks.task,
+		title: juniorEventTasks.title
+	}).from(juniorEventTasks).where(and(eq(juniorEventTasks.teamId, teamId), eq(juniorEventTasks.namespace, event.namespace), eq(juniorEventTasks.identifier, event.identifier), activeEventTaskWhere())).orderBy(asc(juniorEventTasks.createdAtMs), asc(juniorEventTasks.id))).map(parseTask).filter((task) => task.trigger.events.includes(event.eventType) && resourceEventMatches(task.trigger.match, event.data));
+}
+//#endregion
+//#region src/chat/task-outcomes.ts
+const taskMessageDestinationInputSchema = z.union([slackDestinationSchema, z.object({
+	platform: z.literal("slack"),
+	teamId: z.string().min(1),
+	userId: actorUserIdSchema
+}).strict()]);
+/** Input accepted by task authoring tools before a user becomes a DM Destination. */
+const taskOutcomeInputSchema = z.object({
+	action: z.literal("send_message"),
+	destination: taskMessageDestinationInputSchema
+}).strict();
+/** Resolve tool input to the Slack Destinations stored on a task. */
+async function resolveTaskOutcomes(outcomes, currentDestination, creatorSlackUserId) {
+	if (outcomes === void 0) return [{
+		action: "send_message",
+		destination: currentDestination
+	}];
+	const resolved = [];
+	for (const outcome of outcomes) {
+		if (outcome.destination.teamId !== currentDestination.teamId) throw new Error("Message destinations must be in the current Slack workspace.");
+		if ("channelId" in outcome.destination) {
+			if (outcome.destination.channelId !== currentDestination.channelId) throw new Error("Messages can only be sent to the current Slack conversation or the task creator.");
+			resolved.push({
+				action: "send_message",
+				destination: outcome.destination
+			});
+			continue;
+		}
+		const userId = outcome.destination.userId;
+		if (userId !== creatorSlackUserId) throw new Error("Direct messages can only be sent to the task creator.");
+		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;
+}
+/** Return stored outcomes, or preserve the legacy message Destination. */
+function effectiveTaskOutcomes(outcomes, destination) {
+	return outcomes ?? [{
+		action: "send_message",
+		destination
+	}];
+}
+//#endregion
+//#region src/chat/event-tasks/tool-support.ts
+const compactEventTaskResultSchema = z.object({
+	id: z.string().min(1),
+	task: z.string().min(1),
+	namespace: z.string().min(1),
+	identifier: z.string().min(1),
+	resourceType: z.string().min(1),
+	label: z.string().min(1),
+	events: z.array(z.string().min(1)).min(1),
+	match: z.record(z.string(), z.unknown()).optional(),
+	credentialMode: z.enum(["system", "creator"]),
+	outcomes: z.array(taskOutcomeSchema).max(5),
+	createdBy: eventTaskPrincipalSchema,
+	triggerAvailable: z.boolean()
+}).strict();
+/** Validate one successful event-task mutation result. */
+const eventTaskToolResultSchema = juniorToolOutputSchema.extend({ task: compactEventTaskResultSchema }).strict();
+/** Validate one successful event-task list result. */
+const eventTaskListToolResultSchema = juniorToolOutputSchema.extend({
+	tasks: z.array(compactEventTaskResultSchema),
+	truncated: z.boolean()
+}).strict();
+/** Build the validated resource-event trigger accepted by event-task tools. */
+function registeredEventTaskTriggerSchema(catalog) {
+	const plugins = pluginResourceEventCatalog(catalog);
+	return z.object({
+		namespace: eventNamespaceSchema(plugins),
+		identifier: z.string().trim().min(1).max(300),
+		resourceType: registeredResourceTypeSchema(plugins),
+		label: z.string().trim().min(1).max(500),
+		events: z.array(registeredEventTypeSchema(plugins)).min(1),
+		match: registeredResourceEventMatchSchema()
+	}).strict();
+}
+/** Reject an event-task trigger that is no longer supported by the catalog. */
+function requireSupportedEventTaskTrigger(catalog, trigger) {
+	const plugins = pluginResourceEventCatalog(catalog);
+	for (const eventType of trigger.events) if (!pluginSupportsEvent(plugins, trigger.namespace, trigger.resourceType, eventType)) throw new ToolInputError(`Resource type "${trigger.namespace}:${trigger.resourceType}" does not support event "${eventType}".`);
+	return requireSupportedResourceEventMatch(plugins, {
+		match: trigger.match,
+		namespace: trigger.namespace,
+		resourceType: trigger.resourceType
+	});
+}
+/** Require the active Slack authority used for event-task management. */
+function requireEventTaskSlackContext(context) {
+	if (context.source.kind !== "slack" || context.destination.platform !== "slack" || context.actor?.platform !== "slack" || context.actor.teamId !== context.source.teamId) throw new ToolInputError("Event tasks require an active Slack channel or DM and actor.");
+	return {
+		actor: context.actor,
+		destination: {
+			platform: "slack",
+			teamId: context.source.teamId,
+			channelId: context.source.channelId
+		},
+		source: context.source
+	};
+}
+/** Return whether an event task belongs to the active Slack destination. */
+function eventTaskMatchesDestination(task, destination) {
+	return task.destination.teamId === destination.teamId && task.destination.channelId === destination.channelId;
+}
+/**
+* Return whether the active destination may update or delete this task.
+* Same-destination tasks stay local. Public tasks may be managed by id from
+* another destination in the same workspace.
+*/
+function eventTaskIsWritableFrom(task, destination) {
+	if (task.destination.teamId !== destination.teamId) return false;
+	return task.destination.channelId === destination.channelId || task.destinationVisibility === "public";
+}
+/** Load one task the active destination may update or delete. */
+async function writableEventTask(context, id) {
+	const { destination } = requireEventTaskSlackContext(context);
+	const task = await getEventTask(getDb(), id);
+	if (!task || task.status === "deleted" || !eventTaskIsWritableFrom(task, destination)) throw new ToolInputError("Event task was not found.");
+	return task;
+}
+function eventTaskTriggerAvailable(task, catalog) {
+	const registration = pluginResourceEventCatalog(catalog)[task.trigger.namespace];
+	return Boolean(registration && task.trigger.events.every((eventType) => registration.resourceTypes.some((resourceType) => resourceType.supportedEvents.includes(eventType))));
+}
+/** Project an event task into the bounded tool-result shape. */
+function compactEventTask(task, catalog) {
+	return compactEventTaskResultSchema.parse({
+		id: task.id,
+		task: task.task.text,
+		namespace: task.trigger.namespace,
+		identifier: task.trigger.identifier,
+		resourceType: task.trigger.resourceType,
+		label: task.trigger.label,
+		events: task.trigger.events,
+		...task.trigger.match ? { match: task.trigger.match } : void 0,
+		credentialMode: task.credentialMode,
+		outcomes: effectiveTaskOutcomes(task.outcomes, task.destination),
+		createdBy: task.createdBy,
+		triggerAvailable: eventTaskTriggerAvailable(task, catalog)
+	});
+}
+/** Return the standard successful event-task tool result. */
+function eventTaskSuccess(task, catalog) {
+	return { task: compactEventTask(task, catalog) };
+}
+//#endregion
+//#region src/chat/scheduled-tasks/types.ts
+/** Durable scheduled-task domain types owned by Junior core. */
+const scheduledTaskStatusSchema = z.enum([
+	"active",
+	"blocked",
+	"completed",
+	"deleted"
+]);
+const scheduledTaskCredentialModeSchema = z.enum(["system", "creator"]);
+const scheduledRunStatusSchema = z.enum([
+	"pending",
+	"running",
+	"completed",
+	"failed",
+	"blocked",
+	"skipped"
+]);
+const scheduledTaskPrincipalSchema = z.object({
+	slackUserId: actorUserIdSchema,
+	fullName: z.string().optional(),
+	userName: z.string().optional()
+}).strict();
+const scheduledTaskRecurrenceSchema = 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 scheduledTaskScheduleSchema = z.object({
+	description: z.string(),
+	kind: z.enum(["one_off", "recurring"]),
+	recurrence: scheduledTaskRecurrenceSchema.optional(),
+	timezone: z.string()
+}).strict();
+const scheduledTaskExecutionActorSchema = z.object({
+	platform: z.literal("system"),
+	name: z.string()
+}).strict();
+/** Validate the current scheduled-task domain shape. */
+const scheduledTaskSchema = z.object({
+	id: z.string(),
+	conversationAccess: z.object({
+		audience: z.enum([
+			"direct",
+			"group",
+			"channel"
+		]),
+		visibility: z.enum(["private", "public"])
+	}).strict(),
+	createdAtMs: z.number(),
+	createdBy: scheduledTaskPrincipalSchema,
+	/** Authoritative provider identity that created the task. */
+	creatorIdentityId: z.string(),
+	/** Selects system credentials or task-bound creator credential delegation. */
+	credentialMode: scheduledTaskCredentialModeSchema,
+	destination: slackDestinationSchema,
+	executionActor: scheduledTaskExecutionActorSchema.optional(),
+	lastRunAtMs: z.number().optional(),
+	nextRunAtMs: z.number().optional(),
+	originalRequest: z.string().optional(),
+	runNowAtMs: z.number().optional(),
+	schedule: scheduledTaskScheduleSchema,
+	status: scheduledTaskStatusSchema,
+	statusReason: z.string().optional(),
+	/** Visible effects after successful work. Missing legacy values send a message. */
+	outcomes: z.array(taskOutcomeSchema).max(5).optional(),
+	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_TASK_SYSTEM_ACTOR = Object.freeze({
+	platform: "system",
+	name: "scheduled-task"
+});
+//#endregion
+//#region src/chat/scheduled-tasks/tasks.ts
+const SCHEDULER_KEY_PREFIX = "junior:scheduler";
+const retainedScheduledTaskSchema = scheduledTaskSchema.omit({
+	creatorIdentityId: true,
+	title: true
+}).extend({
+	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 parseScheduledTaskRow(row) {
+	const record = z.record(z.string(), z.unknown()).safeParse(row.record);
+	if (!record.success) return void 0;
+	const { creatorIdentityId: legacyCreatorIdentityId, title: legacyTitle, ...retained } = record.data;
+	const parsed = retainedScheduledTaskSchema.safeParse(retained);
+	if (!parsed.success) return void 0;
+	const { status, version: _version, ...task } = parsed.data;
+	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 isListedScheduledTask(task) {
+	return task !== void 0 && task.status !== "deleted";
+}
+/** Build the stable run id for one task occurrence. */
+function scheduledRunId(taskId, scheduledForMs) {
+	return `${taskId}:${scheduledForMs}`;
+}
+/** Acquire the deployed advisory lock for one scheduled task. */
+function withScheduledTaskLock(db, taskId, callback) {
+	return db.transaction(async (tx) => {
+		await tx.execute(sql`SELECT pg_advisory_xact_lock(hashtext(${`${SCHEDULER_KEY_PREFIX}:task:${taskId}:lock`}))`);
+		return await callback(tx);
+	});
+}
+function requireStoredTask(task) {
+	const parsed = scheduledTaskSchema.safeParse(task);
+	if (!parsed.success) throw new Error("Scheduled task routing context is invalid.");
+	const { title, ...current } = parsed.data;
+	const normalizedTitle = title?.trim() || void 0;
+	return {
+		...current,
+		...normalizedTitle ? { title: normalizedTitle } : void 0
+	};
+}
+function scheduledTaskJsonRecord(task) {
+	const { title: _title, ...record } = task;
+	return record;
+}
+async function upsertScheduledTask(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: scheduledTaskJsonRecord(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 task. */
+async function readScheduledTask(db, taskId) {
+	const rows = await db.select({
+		creatorIdentityId: juniorSchedulerTasks.creatorIdentityId,
+		record: juniorSchedulerTasks.record,
+		title: juniorSchedulerTasks.title
+	}).from(juniorSchedulerTasks).where(eq(juniorSchedulerTasks.id, taskId)).limit(1);
+	return rows[0] ? parseScheduledTaskRow(rows[0]) : void 0;
+}
+async function readListedScheduledTasks(db, teamId) {
+	return (await db.select({
+		creatorIdentityId: juniorSchedulerTasks.creatorIdentityId,
+		record: juniorSchedulerTasks.record,
+		title: juniorSchedulerTasks.title
+	}).from(juniorSchedulerTasks).where(and(notInArray(juniorSchedulerTasks.status, ["deleted", "paused"]), teamId === void 0 ? void 0 : eq(juniorSchedulerTasks.teamId, teamId))).orderBy(asc(juniorSchedulerTasks.createdAtMs), asc(juniorSchedulerTasks.id))).map(parseScheduledTaskRow).filter(isListedScheduledTask);
+}
+/** List decoded scheduled tasks in stable creation order. */
+async function listScheduledTasks(db) {
+	return await readListedScheduledTasks(db);
+}
+/** List decoded scheduled tasks for one team in stable creation order. */
+async function listScheduledTasksForTeam(db, teamId) {
+	return await readListedScheduledTasks(db, teamId);
+}
+async function writeScheduledTask(db, task, current) {
+	if (current?.status === "blocked" && task.status === "active" && typeof task.nextRunAtMs === "number" && Number.isFinite(task.nextRunAtMs)) await db.delete(juniorSchedulerRuns).where(and(eq(juniorSchedulerRuns.id, scheduledRunId(task.id, task.nextRunAtMs)), eq(juniorSchedulerRuns.status, "blocked")));
+	if (task.status === "deleted" && current?.status !== "deleted") await skipPendingRunsForDeletedTask(db, task);
+	await upsertScheduledTask(db, task);
+}
+async function skipPendingRunsForDeletedTask(db, task) {
+	const errorMessage = `Scheduled task ${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 task once under its retry-stable task lock. */
+async function createScheduledTask(db, task) {
+	const next = requireStoredTask(task);
+	return await withScheduledTaskLock(db, task.id, async (tx) => {
+		const current = await readScheduledTask(tx, task.id);
+		if (current) return current;
+		await writeScheduledTask(tx, next, void 0);
+		return next;
+	});
+}
+/** Save a scheduled task and clear its blocked occurrence on reactivation. */
+async function saveScheduledTask(db, task) {
+	const next = requireStoredTask(task);
+	await withScheduledTaskLock(db, task.id, async (tx) => {
+		const current = await readScheduledTask(tx, task.id);
+		await writeScheduledTask(tx, next, current);
+	});
+	return next;
+}
+/** Save a scheduled task inside a task lock already held by the caller. */
+async function saveScheduledTaskInLock(db, task, current) {
+	await writeScheduledTask(db, requireStoredTask(task), current);
+}
+/** List scheduled tasks whose current Slack destination is public. */
+async function listPublicScheduledTasksForTeams(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(parseScheduledTaskRow).filter(isListedScheduledTask);
+}
+//#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 { workspaceSnapshotWatch as $, eventTaskTriggerAvailable as A, releaseConversationWork as At, deleteEventTask as B, isInvalidConversationRecordError as Bt, SCHEDULED_TASK_SYSTEM_ACTOR as C, ensureConversationWake as Ct, eventTaskMatchesDestination as D, listActiveConversationIds as Dt, eventTaskListToolResultSchema as E, hasRunnableConversationWork as Et, effectiveTaskOutcomes as F, stopConversationWork as Ft, listEventTasksCreatedBy as G, buildDeterministicTurnId as Gt, findMatchingEventTasks as H, juniorToolOutputSchema as Ht, resolveTaskOutcomes as I, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS as It, saveEventTask as J, listEventTasksForTeam as K, taskOutcomeInputSchema as L, CONVERSATION_WORK_STALE_ENQUEUE_MS as Lt, requireEventTaskSlackContext as M, requestAnotherSlice as Mt, requireSupportedEventTaskTrigger as N, requestConversationWork as Nt, eventTaskSuccess as O, recordAttemptFailure as Ot, writableEventTask as P, startConversationWork as Pt, workspaceSnapshotFinishedEvent as Q, collectEventTaskMatchKeys as R, hasRunnableConversationWork$1 as Rt, withScheduledTaskLock as S, drainConversationMailbox as St, compactEventTask as T, getConversationWorkState as Tt, getEventTask as U, makeStructuredToolOutput as Ut, eventTaskBelongsToUser as V, injectContinuationToolName as Vt, listDeletedEventTasksCreatedBy as W, buildDeterministicAssistantMessageId as Wt, WORKSPACE_SNAPSHOT_FAILED_EVENT as X, getResourceEventCatalog as Y, WORKSPACE_SNAPSHOT_READY_EVENT as Z, parseScheduledTaskRow as _, clearExpiredConversationLease as _t, requestAttachmentDeletion as a, registeredEventTypeSchema as at, saveScheduledTaskInLock as b, countPendingConversationMessages as bt, parseSlackThreadId as c, requireSupportedResourceEventMatch as ct, resolveSlackChannelIdFromThreadId as d, appendAndEnqueueExclusiveInboundMessage as dt, eventNamespaceSchema as et, createScheduledTask as f, appendAndEnqueueInboundMessage as ft, listScheduledTasksForTeam as g, clearConsumedConversationWake as gt, listScheduledTasks as h, checkInConversationWork as ht, readLiveAttachment as i, pluginSupportsEvent as it, registeredEventTaskTriggerSchema as j, removeActiveConversation as jt, eventTaskToolResultSchema as k, recordConversationRetry as kt, readSlackRawMessageContext as l, resourceEventGuidance as lt, listPublicScheduledTasksForTeams as m, cancelHumanFacingPendingMessages as mt, readStats as n, hasResourceEventCatalogEntries as nt, storeAttachment as o, registeredResourceEventMatchSchema as ot, isListedScheduledTask as p, beginConversationResume as pt, listPublicEventTasksForTeams as q, collectAttachmentGarbage as r, normalizeEventIdentifier as rt, storeAttachments as s, registeredResourceTypeSchema as st, incrementStat as t, hasPluginResourceEventCatalogEntries as tt, resolveSlackChannelIdFromMessage as u, ackMessages as ut, readScheduledTask as v, completeConversationStop as vt, scheduledRunSchema as w, getConversation as wt, scheduledRunId as x, deadLetterAttempt as xt, saveScheduledTask as y, completeConversationWork as yt, createEventTask as z, isFinalAttempt as zt };