@sentry/junior 0.266.0 → 0.267.0

package/dist/{tasks-DDT-J3Rf.js → tasks-0ilmuCux.js}

@@ -1,22 +1,22 @@
-import { a as completeText, f as unwrapCurrentInstruction, p as escapeXml, s as resolveGatewayModel, y as isProviderRetryError } from "./client-B0YZfxNy.js";
-import { n as botConfig } from "./config-C0UwYqDK.js";
-import { V as toOptionalString, f as logException, m as logWarn, o as getActiveTraceId, t as buildTurnFailureResponse, y as setSpanAttributes, z as isRecord } from "./logging-Ce0mXZ8J.js";
-import { c as toStoredSlackActor, g as parseSlackMessageTs } from "./actor-tlxzqaRe.js";
-import { S as bindProviderConversation, b as startLocationThread, d as getConversationStore, f as getDb, h as withConversationEventLock, l as getConversationEventStore, m as createSqlConversationEventStore, p as getSqlExecutor, w as addAgentTurnUsage } from "./viewer-BpE6Z3qf.js";
+import { a as completeText, f as unwrapCurrentInstruction, p as escapeXml, s as resolveGatewayModel, y as isProviderRetryError } from "./client-BjgbMawj.js";
+import { i as getChatConfig, n as botConfig } from "./config-CdB6yJj5.js";
+import { B as isRecord, H as toOptionalString, V as toOptionalNumber, b as setSpanAttributes, h as logWarn, o as getActiveTraceContext, p as logException, t as buildTurnFailureResponse } from "./logging-DuZ1A4ab.js";
+import { c as toStoredSlackActor, p as parseSlackMessageTs, s as parseStoredSlackActor } from "./actor-DZSokpwj.js";
+import { B as parseDestination, C as bindProviderConversation, H as sameDestination, T as addAgentTurnUsage, f as getConversationStore, g as withConversationEventLock, h as createSqlConversationEventStore, m as getSqlExecutor, p as getDb, u as getConversationEventStore, x as startLocationThread } from "./viewer-DrN3oC2X.js";
 import { d as juniorDestinations } from "./agent-invocations-CxKldAeB.js";
-import { a as juniorAutomationRuns, l as juniorLocationConfigurations, o as juniorAutomationVersions, s as juniorAutomations } from "./executor-TnWbvL09.js";
+import { a as juniorAutomationRuns, l as juniorLocationConfigurations, o as juniorAutomationVersions, s as juniorAutomations } from "./executor-VYrx_K4w.js";
 import { d as contextProvenance, f as instructionActors, n as agentHistoryItemSchema, p as instructionProvenanceFor } from "./history-C84mlAwO.js";
-import { f as credentialContextForActor, h as credentialSubjectSchema } from "./registry-1BEIPdbT.js";
-import { n as pluginCatalogRuntime } from "./catalog-runtime-DAJjAbSx.js";
-import { An as createPluginLogger, Q as parseSandboxEgressAuthRequiredSignal, ar as agentsInstructionsUpdatedEvent, at as formatProviderLabel, ct as startOAuthFlow, ir as JUNIOR_NATIVE_EVENT_NAMESPACE, mn as ToolInputError, nr as createPluginCache, nt as resolveSandboxEgressProviderForHost, on as sleep, or as authenticationLinkedEvent, p as getPlugins, sr as authenticationUnlinkedEvent, t as executeCredentialedEgressRequest } from "./credentialed-enF5Bf3y.js";
-import { i as MUTATION_LOCK_TTL_MS, o as fenceLock, r as getStateAdapter, s as withLock } from "./adapter-eRFA_naf.js";
-import { N as messageCardRef } from "./conversation-DF4rUcjb.js";
-import { A as eventAutomationSchema, E as scheduledAutomationSchema, S as automationVersionSchema } from "./automation-BKpY9LPa.js";
+import { f as credentialContextForActor, h as credentialSubjectSchema } from "./registry-FQutO926.js";
+import { n as pluginCatalogRuntime } from "./catalog-runtime-cMlAI5LY.js";
+import { H as startOAuthFlow, Nn as createPluginLogger, St as resolveSandboxEgressProviderForHost, ar as createPluginCache, cn as sleep$1, cr as agentsInstructionsUpdatedEvent, dn as JUNIOR_THREAD_STATE_TTL_MS, gn as ToolInputError, lr as authenticationLinkedEvent, p as getPlugins, sr as JUNIOR_NATIVE_EVENT_NAMESPACE, t as executeCredentialedEgressRequest, ur as authenticationUnlinkedEvent, vt as parseSandboxEgressAuthRequiredSignal, z as formatProviderLabel } from "./credentialed-CIGwoLU2.js";
+import { a as MUTATION_LOCK_TTL_MS, c as withLock, i as getStateAdapter, r as getDefaultRedisStateAdapterFor, s as fenceLock } from "./adapter-BybMEezj.js";
+import { L as messageCardRef } from "./conversation-DSo310Ps.js";
+import { A as eventAutomationSchema, E as scheduledAutomationSchema, S as automationVersionSchema } from "./automation-CmeFBSEh.js";
 import { isDeepStrictEqual } from "node:util";
 import { z } from "zod";
 import { createHash, randomUUID } from "node:crypto";
-import { and, asc, desc, eq, inArray, ne, or, sql } from "drizzle-orm";
-import { actorSchema, eventMatches, sourceSchema } from "@sentry/junior-plugin-api";
+import { and, asc, desc, eq, inArray, isNull, ne, or, sql } from "drizzle-orm";
+import { actorSchema, anyResourceMatchFields, describeEventTrigger, destinationSchema, eventMatchSchema, eventMatches, eventTriggerChoices, eventTriggerProblems, normalizeEventIdentifier, normalizeEventMatch, sourceSchema } from "@sentry/junior-plugin-api";
 // src/chat/configuration/defaults.ts
 let installDefaults = {};
 function cloneDefaults(defaults) {
@@ -1038,7 +1038,7 @@ async function persistWithRetry(persist) {
 		return;
 	} catch (error) {
 		lastError = error;
-		if (attempt < PERSIST_ATTEMPTS) await sleep(attempt * 100);
+		if (attempt < PERSIST_ATTEMPTS) await sleep$1(attempt * 100);
 	}
 	throw lastError;
 }
@@ -1105,6 +1105,1161 @@ function buildTurnLimitResponse(eventId) {
 function buildTurnErrorResponse(error, eventId) {
 	return isTurnExecutionLimitExceededError(error) ? buildTurnLimitResponse(eventId) : buildTurnFailureResponse(eventId);
 }
+// src/chat/task-execution/state.ts
+/**
+* Expiring conversation mailbox and execution index store.
+*
+* The conversation record owns pending inbound work, execution status, and the
+* lease. `conversation:active` feeds heartbeat recovery and contains every
+* non-idle conversation until the lease/status path makes it idle.
+* `conversation:by-activity` supports legacy SQL import only; SQL owns durable
+* conversation metadata in configured runtime.
+*/
+const CONVERSATION_PREFIX = "junior:conversation:v2";
+const CONVERSATION_SCHEMA_VERSION = 2;
+const CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH = 1e4;
+const CONVERSATION_INDEX_LOCK_TTL_MS = 1e4;
+const CONVERSATION_INDEX_LOCK_WAIT_MS = 2e3;
+const CONVERSATION_INDEX_LOCK_RETRY_MS = 25;
+const CONVERSATION_MUTATION_LOCK_TTL_MS = 1e4;
+const CONVERSATION_MUTATION_WAIT_MS = 1e4;
+const CONVERSATION_MUTATION_RETRY_MS = 25;
+var InvalidConversationRecordError = class extends Error {
+	constructor(conversationId) {
+		super(`Conversation record is invalid for ${conversationId}`);
+		this.name = "InvalidConversationRecordError";
+	}
+};
+/** Return whether an error means a stored conversation record failed validation. */
+function isInvalidConversationRecordError(error) {
+	return error instanceof InvalidConversationRecordError;
+}
+var ConversationMutationFencedError = class extends Error {
+	constructor(conversationId) {
+		super(`Conversation mutation lock was lost before write for ${conversationId}`);
+		this.name = "ConversationMutationFencedError";
+	}
+};
+const CONVERSATION_BY_ACTIVITY_INDEX_KEY = `${CONVERSATION_PREFIX}:by-activity`;
+const CONVERSATION_ACTIVE_INDEX_KEY = `${CONVERSATION_PREFIX}:active`;
+const CONVERSATION_WORK_LEASE_TTL_MS = 9e4;
+const CONVERSATION_WORK_CHECK_IN_INTERVAL_MS = 15e3;
+const CONVERSATION_WORK_STALE_ENQUEUE_MS = 6e4;
+const inboundMessageSourceSchema = z.enum([
+	"api",
+	"internal",
+	"local",
+	"plugin",
+	"event",
+	"scheduler",
+	"slack",
+	"web"
+]);
+const agentInputSchema = z.object({
+	attachments: z.array(z.unknown()).optional(),
+	authorId: z.string().min(1).optional(),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+	text: z.string()
+}).strict().refine((input) => input.text.trim() || input.attachments?.length, { message: "agent input requires text or attachments" });
+/** Durable delivery modes for pending inbound mailbox work. */
+const inboundMessageDeliverySchema = z.enum(["defer", "interrupt"]);
+/** Sentry trace propagation headers. A malformed value is dropped, not rejected. */
+const traceContextSchema = z.object({
+	baggage: z.string().optional(),
+	sentryTrace: z.string().min(1)
+}).optional().catch(void 0);
+/** 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,
+	traceContext: traceContextSchema
+}).strict().extend({ publishExternally: z.boolean() });
+function conversationKey(conversationId) {
+	return `${CONVERSATION_PREFIX}:${conversationId}`;
+}
+function conversationStopKey(conversationId) {
+	return `${CONVERSATION_PREFIX}:stop:${conversationId}`;
+}
+function indexLockKey(indexKey) {
+	return `${indexKey}:lock`;
+}
+function mutationLockKey(conversationId) {
+	return `${CONVERSATION_PREFIX}:mutation:${conversationId}`;
+}
+function now() {
+	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, traceContext, ...message } = parsed.data;
+	return traceContext ? {
+		...message,
+		traceContext
+	} : 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(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(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(value)) return;
+	const status = normalizeExecutionStatus(value.status);
+	if (!status) return;
+	const pendingMessages = [];
+	if (Array.isArray(value.pendingMessages)) {
+		for (const rawMessage of value.pendingMessages) {
+			const message = normalizeMessage(rawMessage);
+			if (!message || message.conversationId !== conversationId) return;
+			if (message.injectedAtMs !== void 0) continue;
+			pendingMessages.push(message);
+		}
+		pendingMessages.sort(compareMessages);
+	}
+	const inboundMessageIds = Array.isArray(value.inboundMessageIds) ? uniqueStrings(value.inboundMessageIds.map((id) => typeof id === "string" ? id : void 0).filter((id) => Boolean(id))) : [];
+	const lease = normalizeLease(value.lease);
+	const runId = toOptionalString(value.runId);
+	return {
+		status: status === "idle" && lease ? "running" : status === "idle" && pendingMessages.length > 0 ? "pending" : status,
+		inboundMessageIds: uniqueStrings([...inboundMessageIds, ...pendingMessages.map((message) => message.inboundMessageId)]),
+		pendingCount: pendingMessages.length,
+		pendingMessages,
+		lease,
+		lastCheckpointAtMs: toOptionalNumber(value.lastCheckpointAtMs),
+		lastEnqueuedAtMs: toOptionalNumber(value.lastEnqueuedAtMs),
+		lastProgressAtMs: toOptionalNumber(value.lastProgressAtMs),
+		retryCount: toOptionalNumber(value.retryCount),
+		runId,
+		updatedAtMs: toOptionalNumber(value.updatedAtMs)
+	};
+}
+/** Decode current conversation records. */
+function normalizeConversation(conversationId, value) {
+	if (!isRecord(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();
+	let lock;
+	while (true) {
+		lock = await state.acquireLock(indexLockKey(indexKey), CONVERSATION_INDEX_LOCK_TTL_MS);
+		if (lock) break;
+		if (now() - 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(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 === "junior:conversation:v2:by-activity") return entries.sort(compareIndexDescending).slice(0, CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH);
+	if (indexKey === "junior:conversation:v2:active") 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 === "junior:conversation:v2:by-activity") {
+				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 === "junior:conversation:v2:active") {
+				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();
+	while (true) {
+		const lock = await state.acquireLock(mutationLockKey(conversationId), CONVERSATION_MUTATION_LOCK_TTL_MS);
+		if (lock) return lock;
+		if (now() - startedAtMs >= CONVERSATION_MUTATION_WAIT_MS) throw new Error(`Could not acquire conversation mutation lock for ${conversationId}`);
+		await sleep(CONVERSATION_MUTATION_RETRY_MS);
+	}
+}
+async function withConversationMutation(args, callback) {
+	const state = await getConnectedState(args.state);
+	const lock = await acquireMutationLock(state, args.conversationId);
+	try {
+		return await callback(state, lock);
+	} finally {
+		await state.releaseLock(lock);
+	}
+}
+async function readConversation(state, conversationId) {
+	const raw = await state.get(conversationKey(conversationId));
+	if (raw == null) return;
+	const conversation = normalizeConversation(conversationId, raw);
+	if (!conversation) throw new InvalidConversationRecordError(conversationId);
+	return conversation;
+}
+/**
+* Persist a conversation and refresh its reporting and active-recovery indexes.
+*
+* Conversation writes are lock-serialized blind whole-record writes, so the
+* mutation lock is re-validated (and extended) immediately before the write:
+* a stalled mutator that lost its lock must fail loudly instead of clobbering
+* a newer record with a stale copy.
+*/
+async function writeConversation(state, lock, conversation) {
+	const execution = executionWithPendingMessages(conversation.execution, conversation.execution.pendingMessages);
+	const next = {
+		...conversation,
+		execution
+	};
+	await fenceConversationMutation(state, lock, next.conversationId);
+	const hasSlackDestination = next.destination?.platform === "slack";
+	const stored = {
+		...next,
+		execution: {
+			...next.execution,
+			pendingMessages: next.execution.pendingMessages.map((message) => storeMessage(message, hasSlackDestination && (message.source === "slack" || message.source === "event" || message.source === "plugin" || message.source === "scheduler")))
+		}
+	};
+	await state.set(conversationKey(next.conversationId), stored, JUNIOR_THREAD_STATE_TTL_MS);
+	await upsertIndexEntry({
+		state,
+		indexKey: CONVERSATION_BY_ACTIVITY_INDEX_KEY,
+		conversationId: next.conversationId,
+		score: next.lastActivityAtMs
+	});
+	if (!hasRunnableWork(next)) {
+		await removeIndexEntry({
+			state,
+			indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
+			conversationId: next.conversationId
+		});
+		return;
+	}
+	await upsertIndexEntry({
+		state,
+		indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
+		conversationId: next.conversationId,
+		score: next.execution.updatedAtMs ?? next.updatedAtMs
+	});
+}
+function assertSameOptionalConversationDestination(args) {
+	if (!args.next || !args.current) return;
+	if (sameDestination(args.current, args.next)) return;
+	throw new Error(`Conversation destination changed for ${args.conversationId}`);
+}
+function conversationWorkState(conversation) {
+	const lease = conversation.execution.lease;
+	return {
+		...conversation,
+		lastEnqueuedAtMs: conversation.execution.lastEnqueuedAtMs,
+		...lease ? { lease: {
+			acquiredAtMs: lease.acquiredAtMs,
+			lastCheckInAtMs: lease.lastCheckInAtMs,
+			leaseExpiresAtMs: lease.expiresAtMs,
+			leaseToken: lease.token
+		} } : void 0,
+		messages: pendingMessages(conversation),
+		needsRun: hasRunnableWork(conversation)
+	};
+}
+/** Return a persisted conversation record, if one exists. */
+async function getConversation(args) {
+	return await readConversation(await getConnectedState(args.state), args.conversationId);
+}
+/** Return a persisted conversation work record, if one exists. */
+async function getConversationWorkState(args) {
+	const conversation = await getConversation(args);
+	return conversation ? conversationWorkState(conversation) : void 0;
+}
+/** Return whether a conversation has pending or resumable execution work. */
+function hasRunnableConversationWork(conversation) {
+	return hasRunnableWork(conversation);
+}
+async function appendInboundMessageWithAdmission(args) {
+	const nowMs = args.nowMs ?? now();
+	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(args) {
+	const nowMs = args.nowMs ?? now();
+	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(args) {
+	const nowMs = args.nowMs ?? now();
+	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(args) {
+	const nowMs = args.nowMs ?? now();
+	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(args) {
+	const nowMs = args.nowMs ?? now();
+	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(args) {
+	const nowMs = args.nowMs ?? now();
+	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(args) {
+	const nowMs = args.nowMs ?? now();
+	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(args) {
+	const nowMs = args.nowMs ?? now();
+	const inboundMessageIds = new Set(args.inboundMessageIds);
+	return await withConversationMutation(args, async (state, lock) => {
+		const current = await readConversation(state, args.conversationId);
+		if (!current || current.execution.lease?.token !== args.leaseToken) return false;
+		if (inboundMessageIds.size === 0) return true;
+		const pendingMessages = current.execution.pendingMessages.filter((message) => !inboundMessageIds.has(message.inboundMessageId));
+		if (pendingMessages.length === current.execution.pendingMessages.length) return true;
+		await writeConversation(state, lock, withExecutionUpdate(current, {
+			...current.execution,
+			lastProgressAtMs: nowMs,
+			retryCount: 0,
+			pendingMessages
+		}, nowMs));
+		return true;
+	});
+}
+function isHumanFacingMessage(message) {
+	return message.source === "web" || message.source === "slack";
+}
+async function readConversationStop(state, conversationId) {
+	return normalizeStop(await state.get(conversationStopKey(conversationId)));
+}
+async function fenceConversationMutation(state, lock, conversationId) {
+	if (!await state.extendLock(lock, CONVERSATION_MUTATION_LOCK_TTL_MS)) throw new ConversationMutationFencedError(conversationId);
+}
+/** Return whether one Conversation run has a durable stop request. */
+async function hasConversationStop(args) {
+	return (await readConversationStop(await getConnectedState(args.state), args.conversationId))?.runId === args.runId;
+}
+/** Persist a stop request for the current run without process affinity. */
+async function stopConversationWork(args) {
+	const nowMs = args.nowMs ?? now();
+	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 pendingMessages = current.execution.pendingMessages.filter(isHumanFacingMessage);
+		const inboundMessageIds = pendingMessages.map((message) => message.inboundMessageId);
+		if (current.execution.runId === void 0) await writeConversation(state, lock, withExecutionUpdate(current, {
+			...current.execution,
+			runId
+		}, nowMs));
+		await fenceConversationMutation(state, lock, args.conversationId);
+		await state.set(conversationStopKey(args.conversationId), {
+			inboundMessageIds,
+			runId
+		}, JUNIOR_THREAD_STATE_TTL_MS);
+		return {
+			runId,
+			status: "requested",
+			pendingMessages
+		};
+	});
+}
+/** Clear one observed stop request and discard older human-facing mailbox work. */
+async function completeConversationStop(args) {
+	const nowMs = args.nowMs ?? now();
+	return await withConversationMutation(args, async (state, lock) => {
+		const current = await readConversation(state, args.conversationId);
+		if (!current || current.execution.lease?.token !== args.leaseToken) return {
+			status: "lost_lease",
+			removedInboundMessageIds: []
+		};
+		const stop = await readConversationStop(state, args.conversationId);
+		if (!stop || stop.runId !== args.runId) return {
+			status: "none",
+			removedInboundMessageIds: []
+		};
+		const stoppedInboundMessageIds = new Set(stop.inboundMessageIds);
+		const removedInboundMessageIds = [];
+		const pendingMessages = current.execution.pendingMessages.filter((message) => {
+			const shouldStop = stoppedInboundMessageIds.has(message.inboundMessageId);
+			if (shouldStop) removedInboundMessageIds.push(message.inboundMessageId);
+			return !shouldStop;
+		});
+		await writeConversation(state, lock, withExecutionUpdate(current, {
+			...current.execution,
+			lastEnqueuedAtMs: pendingMessages.length === 0 ? void 0 : current.execution.lastEnqueuedAtMs,
+			pendingMessages
+		}, nowMs));
+		await fenceConversationMutation(state, lock, args.conversationId);
+		await state.delete(conversationStopKey(args.conversationId));
+		return {
+			status: "cleared",
+			removedInboundMessageIds
+		};
+	});
+}
+/** Cancel human-facing pending mailbox rows without requiring a worker lease. */
+async function cancelHumanFacingPendingMessages(args) {
+	const nowMs = args.nowMs ?? now();
+	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: [],
+			cancelledMessages: []
+		};
+		const cancelledInboundMessageIds = [];
+		const cancelledMessages = [];
+		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);
+				cancelledMessages.push(message);
+				continue;
+			}
+			pendingMessages.push(message);
+		}
+		if (cancelledInboundMessageIds.length === 0) return {
+			cancelledInboundMessageIds,
+			cancelledMessages
+		};
+		const becomesIdle = current.execution.status === "pending" && pendingMessages.length === 0;
+		await writeConversation(state, lock, withExecutionUpdate(current, {
+			...current.execution,
+			lastEnqueuedAtMs: pendingMessages.length === 0 ? void 0 : current.execution.lastEnqueuedAtMs,
+			pendingMessages,
+			retryCount: becomesIdle ? 0 : current.execution.retryCount,
+			runId: becomesIdle ? void 0 : current.execution.runId,
+			status: becomesIdle ? "idle" : current.execution.status
+		}, nowMs));
+		return {
+			cancelledInboundMessageIds,
+			cancelledMessages
+		};
+	});
+}
+/**
+* Mark one author's queued web messages as interrupts without a worker lease.
+*
+* The active Turn drains them at its next model boundary when it belongs to the
+* same author. Otherwise they start the next Turn ahead of deferred input.
+*/
+async function steerWebPendingMessages(args) {
+	const nowMs = args.nowMs ?? now();
+	const requestedIds = new Set(args.inboundMessageIds);
+	return await withConversationMutation(args, async (state, lock) => {
+		const current = await readConversation(state, args.conversationId);
+		if (!current) return { steeredInboundMessageIds: [] };
+		const steeredInboundMessageIds = [];
+		const pendingMessages = current.execution.pendingMessages.map((message) => {
+			if (message.source !== "web" || message.delivery !== "defer" || message.input.authorId !== args.authorId || !requestedIds.has(message.inboundMessageId)) return message;
+			steeredInboundMessageIds.push(message.inboundMessageId);
+			return {
+				...message,
+				delivery: "interrupt"
+			};
+		});
+		if (steeredInboundMessageIds.length === 0) return { steeredInboundMessageIds };
+		await writeConversation(state, lock, withExecutionUpdate(current, {
+			...current.execution,
+			pendingMessages
+		}, nowMs));
+		return { steeredInboundMessageIds };
+	});
+}
+/** Mark the leased conversation as needing another queue-delivered slice. */
+async function requestAnotherSlice(args) {
+	const nowMs = args.nowMs ?? now();
+	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(args) {
+	const nowMs = args.nowMs ?? now();
+	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(args) {
+	const nowMs = args.nowMs ?? now();
+	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(args) {
+	const nowMs = args.nowMs ?? now();
+	return await withConversationMutation(args, async (state, lock) => {
+		const current = await readConversation(state, args.conversationId);
+		if (!current || current.execution.lease?.token !== args.leaseToken) return "lost_lease";
+		const count = (current.execution.retryCount ?? 0) + 1;
+		const stopped = count >= 5;
+		await writeConversation(state, lock, withExecutionUpdate(current, {
+			...current.execution,
+			lastEnqueuedAtMs: void 0,
+			lease: stopped ? void 0 : current.execution.lease,
+			retryCount: count,
+			pendingMessages: stopped ? [] : current.execution.pendingMessages,
+			runId: stopped ? void 0 : current.execution.runId,
+			status: stopped ? "failed" : "paused"
+		}, nowMs));
+		return stopped ? "stopped" : "recorded";
+	});
+}
+/** Finish a leased conversation and report whether runnable work remains. */
+async function completeConversationWork(args) {
+	const nowMs = args.nowMs ?? now();
+	return await withConversationMutation(args, async (state, lock) => {
+		const current = await readConversation(state, args.conversationId);
+		if (!current || current.execution.lease?.token !== args.leaseToken) return "lost_lease";
+		const hasPending = pendingMessages(current).length > 0;
+		const stopped = args.resumeIfStopped === true && (await readConversationStop(state, args.conversationId))?.runId === current.execution.runId;
+		const needsRun = current.execution.status === "paused" || stopped;
+		const runnable = needsRun || hasPending;
+		await writeConversation(state, lock, withExecutionUpdate(current, {
+			...current.execution,
+			lease: void 0,
+			status: needsRun ? "paused" : hasPending ? "pending" : "idle",
+			lastProgressAtMs: args.madeProgress === false ? current.execution.lastProgressAtMs : nowMs,
+			retryCount: runnable || args.madeProgress === false ? current.execution.retryCount : 0,
+			runId: runnable ? current.execution.runId : void 0
+		}, nowMs));
+		return runnable ? "pending" : "completed";
+	});
+}
+/**
+* Record one failed execution attempt for pending messages, dead-lettering
+* the conversation when its retry budget or the legacy message delivery limit
+* is exhausted.
+*
+* Retries are counted only when the run made no durable progress: if any
+* attempted message left the mailbox, the remaining pending entries may be
+* deliberate deferrals and are left untouched. Consumed message ids stay in
+* `inboundMessageIds` so source retries remain duplicates.
+*/
+async function recordAttemptFailure(args) {
+	const nowMs = args.nowMs ?? now();
+	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(args) {
+	const nowMs = args.nowMs ?? now();
+	return await withConversationMutation(args, async (state, lock) => {
+		const current = await readConversation(state, args.conversationId);
+		if (!current || current.execution.lease?.token !== args.leaseToken) return "lost_lease";
+		const runnable = pendingMessages(current).length > 0;
+		await writeConversation(state, lock, withExecutionUpdate(current, {
+			...current.execution,
+			lease: void 0,
+			status: runnable ? "pending" : "failed",
+			runId: runnable ? current.execution.runId : void 0
+		}, nowMs));
+		return runnable ? "pending" : "failed";
+	});
+}
+/** Recover an expired lease, consuming the retry budget under the mutation lock. */
+async function clearExpiredConversationLease(args) {
+	const nowMs = args.nowMs ?? now();
+	return await withConversationMutation(args, async (state, lock) => {
+		const current = await readConversation(state, args.conversationId);
+		if (!current?.execution.lease || current.execution.lease.expiresAtMs > nowMs) return "not_expired";
+		const retryCount = (current.execution.retryCount ?? 0) + 1;
+		const stopped = retryCount >= 5;
+		await writeConversation(state, lock, withExecutionUpdate(current, {
+			...current.execution,
+			lastEnqueuedAtMs: void 0,
+			lease: void 0,
+			retryCount,
+			pendingMessages: stopped ? [] : current.execution.pendingMessages,
+			runId: stopped ? void 0 : current.execution.runId,
+			status: stopped ? "failed" : "paused"
+		}, nowMs));
+		return stopped ? "stopped" : "requeued";
+	});
+}
+/** Remove one conversation from the active index after it is missing or idle. */
+async function removeActiveConversation(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(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);
+}
 // src/chat/task-execution/turn-cursor-keys.ts
 /** Redis namespace for the current turn cursor format. */
 const TURN_CURSOR_PREFIX = "junior:turn_cursor:v2";
@@ -1216,7 +2371,7 @@ const storedTurnRecordSchema = z.object({
 	startedAtMs: nonNegativeNumberSchema,
 	state: turnStatusSchema,
 	surface: turnSurfaceSchema.optional(),
-	traceId: z.string().optional(),
+	traceContext: traceContextSchema,
 	updatedAtMs: nonNegativeNumberSchema,
 	committedSeq: seqCursorSchema,
 	historyVersion: z.number().int().nonnegative().optional(),
@@ -1331,7 +2486,7 @@ function materializeTurnRecord(stored, piProjection, turnStartMessageIndex, runt
 			resultMessageId: stored.resultMessageId,
 			resumedFromSliceId: stored.resumedFromSliceId,
 			surface: stored.surface,
-			traceId: stored.traceId,
+			traceContext: stored.traceContext,
 			turnStartMessageIndex
 		})
 	};
@@ -1404,7 +2559,7 @@ function buildStoredRecord(args) {
 			resultMessageId: args.resultMessageId,
 			resumedFromSliceId: args.resumedFromSliceId,
 			surface: args.surface,
-			traceId: args.traceId,
+			traceContext: args.traceContext,
 			turnStartSeq: args.turnStartSeq
 		})
 	};
@@ -1482,7 +2637,7 @@ async function updateTurnState(args) {
 				resultMessageId: args.resultMessageId ?? args.existing.resultMessageId,
 				resumedFromSliceId: args.existing.resumedFromSliceId,
 				surface: args.existing.surface,
-				traceId: args.existing.traceId,
+				traceContext: args.existing.traceContext,
 				turnStartSeq: parsed.turnStartSeq
 			})
 		})
@@ -1559,7 +2714,7 @@ async function upsertTurnRecordLocked(args, fence) {
 				resumedFromSliceId: args.resumedFromSliceId,
 				startedAtMs: existingRecord?.startedAtMs,
 				surface: args.surface ?? existingRecord?.surface,
-				traceId: args.traceId ?? existingRecord?.traceId,
+				traceContext: args.traceContext ?? existingRecord?.traceContext,
 				turnStartSeq
 			})
 		})
@@ -1728,7 +2883,7 @@ function sharedWrite(args, latest) {
 			dispatchId: args.dispatchId ?? latest?.dispatchId,
 			source: args.source,
 			surface: args.surface ?? latest?.surface,
-			traceId: getActiveTraceId() ?? latest?.traceId,
+			traceContext: latest?.traceContext ?? getActiveTraceContext(),
 			turnStartMessageIndex: args.turnStartMessageIndex ?? latest?.turnStartMessageIndex,
 			cumulativeToolCallCount: args.cumulativeToolCallCount ?? latest?.cumulativeToolCallCount,
 			turnLimitWrappedUp: args.turnLimitWrappedUp ?? latest?.turnLimitWrappedUp,
@@ -3265,6 +4420,138 @@ async function recordGuardianActionReviewed(args) {
 		createdAtMs: Date.now()
 	}]);
 }
+// src/chat/events/catalog.ts
+/** A source with nothing enabled, for a namespace that the catalog lacks. */
+const NO_SOURCE = {
+	resourceTypes: [],
+	events: {},
+	anyResourceFields: {}
+};
+/**
+* Build one catalog entry. It merges the filters of every resource type here,
+* once, so trigger checks for each event copy and each row do not merge them
+* again.
+*/
+function eventCatalogEntry(registration) {
+	return {
+		...registration,
+		anyResourceFields: anyResourceMatchFields(registration.resourceTypes)
+	};
+}
+/** Core-owned event namespace. Not a plugin publisher. */
+const CORE_EVENT_NAMESPACE = "junior";
+/** True when the catalog has any enabled registration. */
+function hasEventCatalogEntries(catalog) {
+	return Object.keys(catalog).length > 0;
+}
+/**
+* Catalog entries that durable event automations may select.
+*
+* Resource types with `automation: false` stay out of create/update schemas
+* and trigger availability. A namespace with no such resource type left is
+* removed.
+*/
+function automationEventCatalog(catalog) {
+	return Object.fromEntries(Object.entries(catalog).flatMap(([namespace, registration]) => {
+		const resourceTypes = registration.resourceTypes.filter((resourceType) => registration.limits?.[resourceType.type]?.automation !== false);
+		if (resourceTypes.length === 0) return [];
+		if (resourceTypes.length === registration.resourceTypes.length) return [[namespace, registration]];
+		const supported = new Set(resourceTypes.flatMap((resourceType) => resourceType.supportedEvents));
+		return [[namespace, eventCatalogEntry({
+			...registration,
+			resourceTypes,
+			events: Object.fromEntries(Object.entries(registration.events).filter(([eventType]) => supported.has(eventType)))
+		})]];
+	}));
+}
+/** Return why watchEvents cannot watch one resource type, if it cannot. */
+function eventWatchUnavailable(catalog, namespace, resourceType) {
+	const limits = catalog[namespace]?.limits?.[resourceType];
+	return limits?.watch === false ? limits.watchUnavailableMessage : void 0;
+}
+function enumSchema(values, unavailableMessage) {
+	if (values.length === 0) return z.string().refine(() => false, unavailableMessage);
+	return z.enum(values);
+}
+/** Build the model-facing namespace enum from enabled event plugins. */
+function eventNamespaceSchema(catalog) {
+	return enumSchema(Object.keys(catalog).sort(), "No event namespaces are enabled.");
+}
+/** Build the model-facing event enum from enabled plugin registrations. */
+function registeredEventTypeSchema(catalog) {
+	return enumSchema([...new Set(Object.values(catalog).flatMap((registration) => registration.resourceTypes.flatMap((resourceType) => resourceType.supportedEvents)))].sort(), "No event types are enabled.");
+}
+/** Build the model-facing resource type enum from enabled plugin registrations. */
+function registeredResourceTypeSchema(catalog) {
+	return enumSchema([...new Set(Object.values(catalog).flatMap((registration) => registration.resourceTypes.map((resourceType) => resourceType.type)))].sort(), "No resource types are enabled.");
+}
+/**
+* Return app guidance for one event of a namespace. The source declares it
+* once for the event, so every resource type and a trigger with no resource
+* type get the same guidance.
+*/
+function eventGuidance(catalog, namespace, eventType) {
+	return catalog[namespace]?.events[eventType]?.guidance;
+}
+/** Build the match object the tools accept for one resource type. */
+function registeredEventMatchSchema() {
+	return eventMatchSchema.optional().describe("Optional filters: exact values for the resource type matchFields. A single value must equal the event data. A list means the event value may be any one entry. For a field with list: true, the event value is a list, and it matches when it includes the value or any entry. A field with events is set only on those events, so every selected event must be in that list. Omit a key to ignore it. Unmatched events are dropped with no agent turn.");
+}
+/**
+* List why a selection cannot work with the enabled plugins. Use it for new
+* selections and for saved triggers, which can go stale after a plugin renames
+* or removes a resource type, event, or filter.
+*/
+function registeredEventTriggerProblems(catalog, selection, options) {
+	return eventTriggerProblems(catalog[selection.namespace] ?? NO_SOURCE, selection, options);
+}
+/**
+* Describe a selection with the enabled plugins, for the dashboard and Slack.
+* Its problems are the same as `registeredEventTriggerProblems`.
+*/
+function describeRegisteredEventTrigger(catalog, selection) {
+	return describeEventTrigger(catalog[selection.namespace] ?? NO_SOURCE, selection);
+}
+function uniqueMatchValues(match) {
+	if (!match || Object.keys(match).length === 0) return void 0;
+	return Object.fromEntries(Object.entries(match).map(([key, value]) => [key, Array.isArray(value) ? [...new Set(value)] : value]));
+}
+/**
+* Reject an event automation trigger or a Watch that cannot work, with every
+* problem in one message for the agent. Return its match as it is saved:
+* each text value in the case that its plugin declares, with no repeated
+* list values.
+*/
+function requireValidEventTrigger(catalog, selection, target) {
+	const fields = eventTriggerChoices(catalog[selection.namespace] ?? NO_SOURCE, selection)?.fields ?? {};
+	const normalized = {
+		...selection,
+		match: normalizeEventMatch(fields, selection.match)
+	};
+	const problems = registeredEventTriggerProblems(catalog, normalized, { inputKeys: true });
+	if (problems.length > 0) {
+		const source = catalog[selection.namespace]?.displayName ?? selection.namespace;
+		const resource = selection.resourceType ? `${source} ${selection.resourceType.replaceAll("_", " ")}` : source;
+		throw new ToolInputError([target === "watch" ? `This ${resource} watch cannot be created.` : `This ${resource} trigger cannot be saved.`, ...problems.map((problem) => problem.message)].join(" "));
+	}
+	return uniqueMatchValues(normalized.match);
+}
+/**
+* Normalize one selector with the convention declared by its plugin.
+*
+* Reject a selector that does not fit its resource type. Resource types can
+* share event types, so only the identifier shows which one a selector names.
+*/
+function requireEventIdentifier(catalog, input) {
+	const registration = catalog[input.namespace];
+	const identifier = normalizeEventIdentifier(registration, input.identifier);
+	const resourceTypes = registration?.resourceTypes ?? [];
+	const fits = (resourceType) => resourceType.identifier !== void 0 && new RegExp(resourceType.identifier.pattern).test(identifier);
+	const resourceType = resourceTypes.find((candidate) => candidate.type === input.resourceType);
+	if (!resourceType?.identifier || fits(resourceType)) return identifier;
+	const fitting = resourceTypes.filter(fits).map((candidate) => candidate.type);
+	throw new ToolInputError([`Identifier "${identifier}" does not fit resourceType "${input.resourceType}" in namespace "${input.namespace}". Expected format: "${resourceType.identifier.format}".`, ...fitting.length > 0 ? [`If the identifier is correct, use one of these resourceType values: ${fitting.map((type) => `"${type}"`).join(", ")}.`] : []].join(" "));
+}
 // src/chat/automations/revision.ts
 /** Storage revisions prevent stale edits from replacing newer values. */
 var AutomationConflictError = class extends ToolInputError {
@@ -3407,6 +4694,14 @@ function eventAutomationRunLimitReason() {
 	const window = describeRunWindow(botConfig.eventAutomationRunWindowMs);
 	return `This automation reached its limit of ${botConfig.maxEventAutomationRuns} runs per ${window}. Check that its trigger is not too broad, then resume it.`;
 }
+function hasRunKey(entries, runKey) {
+	for (let index = entries.length - 1; index >= 0; index -= 1) {
+		const entry = entries[index];
+		if ("reset" in entry) return false;
+		if (entry.id === runKey) return true;
+	}
+	return false;
+}
 /**
 * Count one run of an Event automation, or refuse when its window is full.
 *
@@ -3415,22 +4710,29 @@ function eventAutomationRunLimitReason() {
 */
 async function admitEventAutomationRun(args) {
 	const state = args.state ?? getStateAdapter();
-	await appendRunEntry(state, args.automationId, {
+	await state.connect();
+	const readEntries = async () => {
+		const values = await state.getList(runListKey(args.automationId));
+		return {
+			entries: values.flatMap((value) => {
+				const entry = runEntrySchema.safeParse(value);
+				return entry.success ? [entry.data] : [];
+			}),
+			length: values.length
+		};
+	};
+	if (!hasRunKey((await readEntries()).entries, args.runKey)) await appendRunEntry(state, args.automationId, {
 		atMs: args.nowMs,
 		id: args.runKey
 	});
 	const windowStartMs = args.nowMs - botConfig.eventAutomationRunWindowMs;
-	const values = await state.getList(runListKey(args.automationId));
-	const entries = values.flatMap((value) => {
-		const entry = runEntrySchema.safeParse(value);
-		return entry.success ? [entry.data] : [];
-	});
+	const { entries, length } = await readEntries();
 	let lastReset = -1;
 	entries.forEach((entry, index) => {
 		if ("reset" in entry) lastReset = index;
 	});
 	const oldest = entries[0];
-	const full = lastReset === -1 && values.length >= runListMaxLength() && oldest !== void 0 && "atMs" in oldest && oldest.atMs > windowStartMs;
+	const full = lastReset === -1 && length >= runListMaxLength() && oldest !== void 0 && "atMs" in oldest && oldest.atMs > windowStartMs;
 	const runKeys = /* @__PURE__ */ new Set();
 	for (const entry of entries.slice(lastReset + 1)) {
 		if ("reset" in entry) continue;
@@ -3461,7 +4763,7 @@ function eventAutomationColumns(task) {
 		channelId: record.destination.channelId,
 		creatorIdentityId,
 		creatorSlackUserId: record.createdBy.slackUserId,
-		identifier: record.trigger.identifier,
+		identifier: record.trigger.identifier ?? null,
 		instruction: record.task.text,
 		namespace: record.trigger.namespace,
 		record,
@@ -3469,14 +4771,32 @@ function eventAutomationColumns(task) {
 		title: title?.trim() || null
 	};
 }
-/** Decode an event Automation row with its SQL-backed fields. */
-function parseEventAutomationRow(row) {
-	const task = eventAutomationSchema.parse({
+function eventAutomationRowInput(row) {
+	return {
 		...row.record,
 		createdAtMs: row.createdAtMs,
 		creatorIdentityId: row.creatorIdentityId,
 		id: row.id
+	};
+}
+/** Decode an event Automation row with its SQL-backed fields. */
+function parseEventAutomationRow(row) {
+	return withRowFields(row, eventAutomationSchema.parse(eventAutomationRowInput(row)));
+}
+/**
+* Decode a row for Event matching. Log and skip a row that does not parse,
+* so one bad row cannot stop matching for its whole namespace.
+*/
+function readMatchableEventAutomationRow(row) {
+	const parsed = eventAutomationSchema.safeParse(eventAutomationRowInput(row));
+	if (parsed.success) return withRowFields(row, parsed.data);
+	logWarn("event_automation.row.invalid", {
+		"app.task.id": row.id,
+		"app.task.type": "event",
+		"error.message": parsed.error.message
 	});
+}
+function withRowFields(row, task) {
 	const title = row.title?.trim();
 	return {
 		...task,
@@ -3562,25 +4882,99 @@ async function listDeletedEventAutomationsCreatedBy(db, user, limit) {
 	return (await db.select().from(juniorAutomations).where(and(inArray(juniorAutomations.creatorIdentityId, identityIds), eq(juniorAutomations.kind, "event"), eq(juniorAutomations.status, "deleted"))).orderBy(desc(juniorAutomations.createdAtMs), desc(juniorAutomations.id)).limit(limit)).map(parseEventAutomationRow);
 }
 /**
-* Collect match keys from live event automations for these identifiers and event types.
-* Does not evaluate match values — only reports keys that filters use.
+* Select live rows whose identifier is one of these, and rows with no
+* identifier. A row with no identifier runs for every resource of its
+* namespace, so it gets every copy of an Event.
+*/
+function eventIdentifierWhere(identifiers) {
+	return or(isNull(juniorAutomations.identifier), ...identifiers.length > 0 ? [inArray(juniorAutomations.identifier, [...identifiers])] : []);
+}
+/** SQL for rows whose trigger selects any of these event types. */
+function eventTypesWhere(eventTypes) {
+	return or(...eventTypes.map((eventType) => sql`${juniorAutomations.record}->'trigger'->'events' @> ${JSON.stringify([eventType])}::jsonb`));
+}
+/**
+* Return why a row must not run for an Event with one of these identifiers,
+* or nothing when it may.
+*
+* The identifier column and the saved trigger must agree. A row with no
+* identifier must also have a trigger that the enabled `catalog` accepts. A
+* plugin can later require a filter or stop letting an event run for every
+* resource, and the row must not stay broad.
+*/
+function eventAutomationGateProblem(row, task, identifiers, catalog) {
+	const identifier = task.trigger.identifier;
+	if (identifier !== void 0) return identifier === row.identifier && identifiers.includes(identifier) ? void 0 : "The saved trigger has a different identifier from its row.";
+	if (row.identifier !== null) return "The saved trigger has no identifier, but its row has one.";
+	const problems = registeredEventTriggerProblems(catalog, task.trigger);
+	return problems.length > 0 ? problems.map((problem) => problem.message).join(" ") : void 0;
+}
+/**
+* Read the rows that can match an Event: live rows of one team and
+* namespace whose identifier is one of these, or that have no identifier,
+* and that select one of these event types. Skip and log a row that does
+* not parse or that the gate rejects.
+*/
+async function readGatedEventAutomations(db, input) {
+	const rows = await db.select().from(juniorAutomations).where(and(eq(juniorAutomations.kind, "event"), eq(juniorAutomations.teamId, input.teamId), eq(juniorAutomations.namespace, input.namespace), eventIdentifierWhere(input.identifiers), eventTypesWhere(input.eventTypes), eq(juniorAutomations.status, "active"))).orderBy(asc(juniorAutomations.createdAtMs), asc(juniorAutomations.id));
+	const plugins = automationEventCatalog(input.catalog);
+	return rows.flatMap((row) => {
+		const task = readMatchableEventAutomationRow(row);
+		if (!task) return [];
+		const problem = eventAutomationGateProblem(row, task, input.identifiers, plugins);
+		if (problem === void 0) return [task];
+		logWarn("event_automation.gate.rejected", {
+			"app.task.id": task.id,
+			"app.task.type": "event",
+			"app.event_automation.skip_reason": problem
+		});
+		return [];
+	});
+}
+/** The filters of a match whose keys are in this data. */
+function knownMatch(match, data) {
+	if (!match) return void 0;
+	return Object.fromEntries(Object.entries(match).filter(([key]) => data[key] !== void 0));
+}
+/**
+* Collect match keys from live event automations for these identifiers and
+* event types, and from automations with no identifier. Does not evaluate
+* match values, except for automations with no identifier: one whose
+* filters on the keys in `data` fail adds no keys. So a broad trigger for
+* one repository does not make every repository load its lazy data.
 */
 async function collectEventAutomationMatchKeys(db, input) {
-	const eventTypes = new Set(input.eventTypes.map((eventType) => eventType.trim()).filter(Boolean));
+	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().from(juniorAutomations).where(and(eq(juniorAutomations.kind, "event"), eq(juniorAutomations.teamId, input.teamId), eq(juniorAutomations.namespace, input.namespace), inArray(juniorAutomations.identifier, identifiers), eq(juniorAutomations.status, "active"))).orderBy(asc(juniorAutomations.createdAtMs), asc(juniorAutomations.id));
+	if (eventTypes.length === 0) return [];
+	const tasks = await readGatedEventAutomations(db, {
+		catalog: input.catalog,
+		eventTypes,
+		identifiers,
+		namespace: input.namespace,
+		teamId: input.teamId
+	});
 	const keys = /* @__PURE__ */ new Set();
-	for (const row of rows) {
-		const task = parseEventAutomationRow(row);
-		if (!task.trigger.events.some((eventType) => eventTypes.has(eventType))) continue;
+	for (const task of tasks) {
+		if (task.trigger.identifier === void 0 && input.data && !eventMatches(knownMatch(task.trigger.match, input.data), input.data)) continue;
 		for (const key of Object.keys(task.trigger.match ?? {})) keys.add(key);
 	}
 	return [...keys].sort();
 }
-/** Find every live task matching one normalized event. */
-async function findMatchingEventAutomations(db, event, teamId) {
-	return (await db.select().from(juniorAutomations).where(and(eq(juniorAutomations.kind, "event"), eq(juniorAutomations.teamId, teamId), eq(juniorAutomations.namespace, event.namespace), eq(juniorAutomations.identifier, event.identifier), eq(juniorAutomations.status, "active"))).orderBy(asc(juniorAutomations.createdAtMs), asc(juniorAutomations.id))).map(parseEventAutomationRow).filter((task) => task.trigger.events.includes(event.eventType) && eventMatches(task.trigger.match, event.data));
+/**
+* Find every live task matching one normalized event: tasks for its exact
+* identifier, and tasks with no identifier whose filters match. The gate
+* skips a row whose trigger and identifier column disagree, and a row with
+* no identifier whose trigger the enabled `catalog` rejects.
+*/
+async function findMatchingEventAutomations(db, event, teamId, catalog) {
+	return (await readGatedEventAutomations(db, {
+		catalog,
+		eventTypes: [event.eventType],
+		identifiers: [event.identifier],
+		namespace: event.namespace,
+		teamId
+	})).filter((task) => task.trigger.events.includes(event.eventType) && eventMatches(task.trigger.match, event.data));
 }
 /**
 * Change lifecycle under the same row lock as edits, without changing
@@ -3753,4 +5147,4 @@ async function saveScheduledAutomation(db, task, expectedRevision, editedBy) {
 async function saveScheduledAutomationInLock(db, task, current) {
 	await writeScheduledAutomation(db, requireStoredTask(task), current);
 }
-export { persistConversationMessageSummaries as $, isToolResultMessage as $t, commitAcceptedReply as A, abandonTurnRecord as At, recordAttachmentsDelivered as B, buildTurnErrorResponse as Bt, automationVersionOf as C, getConfigDefaults as Cn, canReusePendingAuthLink as Ct, AutomationConflictError as D, continuableMessages as Dt, sameDefinitionValue as E, wasPendingAuthStopped as Et, loadProjection as F, recordTurnSummary as Ft, recordMcpProviderConnected as G, getPiMessageRole as Gt, recordAuthorizationCompleted as H, isTurnExecutionLimitExceededError as Ht, loadTurnProjection as I, TURN_LIMIT_DISABLED_REASON as It, recordTurnRoute as J, hasRuntimeTurnContext as Jt, recordSubscribedReplyRoute as K, getTerminalAssistantMessages as Kt, loadTurnRoute as L, TurnBudgetExceededError as Lt, loadConnectedMcpProviders as M, failTurnRecord as Mt, loadConversationProjection as N, getTurnRecord as Nt, automationRevision as O, loadTurnCheckpoint as Ot, loadLastModelProfile as P, listTurnSummaries as Pt, projectConversationMessages as Q, isToolResultError as Qt, openConversationProjection as R, TurnSliceLimitExceededError as Rt, automationDefinition as S, piMessageFromHistoryItem as Sn, abandonReplacedPendingAuth as St, readAutomationVersion as T, getConversationPendingAuth as Tt, recordAuthorizationRequested as U, persistWithRetry as Ut, recordAuthenticationLinked as V, createTurnLimitGate as Vt, recordGuardianActionReviewed as W, extractAssistantText as Wt, hydrateConversationMessages as X, isAssistantMessage as Xt, appendConversationMessages as Y, instructionTextForProjection as Yt, persistConversationMessages as Z, isContinuablePiBoundary as Zt, parseEventAutomationRow as _, isExperimentalFeatureEnabled as _n, createPluginAuthOrchestration as _t, saveScheduledAutomation as a, SESSION_CONTEXT_SECTION_TAG as an, buildConversationContext as at, admitEventAutomationRun as b, configValueSchema as bn, AuthorizationFlowDisabledError as bt, withScheduledAutomationLock as c, buildDeterministicTurnId as cn, getConversationMessageSlackTs as ct, createEventAutomation as d, getSubscribedReplyPreflightDecision as dn, normalizeConversationText as dt, normalizeToolNameFromResult as en, resolveConversationTitle as et, deleteEventAutomation as f, getThreadStopDecision as fn, recordDeliveredAssistantMessage as ft, listEventAutomationsForTeam as g, getExperimentalFeatures as gn, PluginCredentialFailureError as gt, listDeletedEventAutomationsCreatedBy as h, getAgentContextInputLimitTokens as hn, createPluginEgress as ht, readScheduledAutomation as i, REQUEST_CONTEXT_SECTION_TAG as in, appendThreadContextMessages as it, commitMessages as j, completeTurnRecord as jt, requireAutomationRevision as k, saveTurnCheckpoint as kt, blockEventAutomation as l, SubscribedReplyReason as ln, isHumanConversationMessage as lt, getEventAutomation as m, getAgentContextCompactionTriggerTokens as mn, upsertConversationMessage as mt, listScheduledAutomationsForTeam as n, stripRuntimeTurnContext as nn, fallbackShortTitle as nt, saveScheduledAutomationInLock as o, TURN_CONTEXT_TAG as on, createConversationMemoryService as ot, findMatchingEventAutomations as p, estimateTextTokens as pn, turnHasReply as pt, recordToolExecutionStarted as q, getUserMessageInstructionText as qt, parseScheduledAutomationRow as r, trimTrailingAssistantMessages as rn, resolveTaskTitle as rt, scheduledRunId as s, buildDeterministicAssistantMessageId as sn, estimateConversationContextTokens as st, createScheduledAutomation as t, retainRuntimeTurnContext as tn, settleConversationTitleWork as tt, collectEventAutomationMatchKeys as u, decideSubscribedThreadReply as un, markConversationMessage as ut, saveEventAutomation as v, setExperimentalFeatures as vn, authorizationId as vt, listAutomationVersions as w, setConfigDefaults as wn, clearPendingAuth as wt, eventAutomationRunLimitReason as x, historyItemFromPiMessage as xn, AuthorizationPauseError as xt, setEventAutomationStatus as y, createDurableLocationConfigurationService as yn, AuthPausePersistenceError as yt, recordAgentsInstructionsUpdated as z, TurnToolCallLimitExceededError as zt };
+export { recordAgentsInstructionsUpdated as $, buildDeterministicTurnId as $n, appendExclusiveInboundMessage as $t, CORE_EVENT_NAMESPACE as A, TurnToolCallLimitExceededError as An, PluginCredentialFailureError as At, registeredEventTypeSchema as B, instructionTextForProjection as Bn, wasPendingAuthStopped as Bt, automationVersionOf as C, requestConversationWork as Cn, isHumanConversationMessage as Ct, AutomationConflictError as D, TURN_LIMIT_DISABLED_REASON as Dn, turnHasReply as Dt, sameDefinitionValue as E, stopConversationWork as En, recordDeliveredAssistantMessage as Et, eventNamespaceSchema as F, extractAssistantText as Fn, AuthorizationPauseError as Ft, commitMessages as G, normalizeToolNameFromResult as Gn, completeTurnRecord as Gt, requireEventIdentifier as H, isContinuablePiBoundary as Hn, loadTurnCheckpoint as Ht, eventWatchUnavailable as I, getPiMessageRole as In, abandonReplacedPendingAuth as It, loadLastModelProfile as J, trimTrailingAssistantMessages as Jn, listTurnSummaries as Jt, loadConnectedMcpProviders as K, retainRuntimeTurnContext as Kn, failTurnRecord as Kt, hasEventCatalogEntries as L, getTerminalAssistantMessages as Ln, canReusePendingAuthLink as Lt, describeRegisteredEventTrigger as M, createTurnLimitGate as Mn, authorizationId as Mt, eventCatalogEntry as N, isTurnExecutionLimitExceededError as Nn, AuthPausePersistenceError as Nt, automationRevision as O, TurnBudgetExceededError as On, upsertConversationMessage as Ot, eventGuidance as P, persistWithRetry as Pn, AuthorizationFlowDisabledError as Pt, openConversationProjection as Q, buildDeterministicAssistantMessageId as Qn, ackMessages as Qt, registeredEventMatchSchema as R, getUserMessageInstructionText as Rn, clearPendingAuth as Rt, automationDefinition as S, requestAnotherSlice as Sn, getConversationMessageSlackTs as St, readAutomationVersion as T, steerWebPendingMessages as Tn, normalizeConversationText as Tt, requireValidEventTrigger as U, isToolResultError as Un, saveTurnCheckpoint as Ut, registeredResourceTypeSchema as V, isAssistantMessage as Vn, continuableMessages as Vt, commitAcceptedReply as W, isToolResultMessage as Wn, abandonTurnRecord as Wt, loadTurnProjection as X, SESSION_CONTEXT_SECTION_TAG as Xn, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS as Xt, loadProjection as Y, REQUEST_CONTEXT_SECTION_TAG as Yn, recordTurnSummary as Yt, loadTurnRoute as Z, TURN_CONTEXT_TAG as Zn, CONVERSATION_WORK_STALE_ENQUEUE_MS as Zt, parseEventAutomationRow as _, markConversationWorkEnqueued as _n, resolveTaskTitle as _t, saveScheduledAutomation as a, clearExpiredConversationLease as an, getAgentContextCompactionTriggerTokens as ar, recordMcpProviderConnected as at, admitEventAutomationRun as b, releaseConversationWork as bn, createConversationMemoryService as bt, withScheduledAutomationLock as c, deadLetterAttempt as cn, isExperimentalFeatureEnabled as cr, recordTurnRoute as ct, createEventAutomation as d, getConversationWorkState as dn, configValueSchema as dr, persistConversationMessages as dt, appendInboundMessage as en, SubscribedReplyReason as er, recordAttachmentsDelivered as et, deleteEventAutomation as f, hasConversationStop as fn, historyItemFromPiMessage as fr, projectConversationMessages as ft, listEventAutomationsForTeam as g, listActiveConversationIds as gn, fallbackShortTitle as gt, listDeletedEventAutomationsCreatedBy as h, isInvalidConversationRecordError as hn, setConfigDefaults as hr, settleConversationTitleWork as ht, readScheduledAutomation as i, clearConsumedConversationWake as in, estimateTextTokens as ir, recordGuardianActionReviewed as it, automationEventCatalog as j, buildTurnErrorResponse as jn, createPluginAuthOrchestration as jt, requireAutomationRevision as k, TurnSliceLimitExceededError as kn, createPluginEgress as kt, blockEventAutomation as l, drainConversationMailbox as ln, setExperimentalFeatures as lr, appendConversationMessages as lt, getEventAutomation as m, isFinalAttempt as mn, getConfigDefaults as mr, resolveConversationTitle as mt, listScheduledAutomationsForTeam as n, cancelHumanFacingPendingMessages as nn, getSubscribedReplyPreflightDecision as nr, recordAuthorizationCompleted as nt, saveScheduledAutomationInLock as o, completeConversationStop as on, getAgentContextInputLimitTokens as or, recordSubscribedReplyRoute as ot, findMatchingEventAutomations as p, hasRunnableConversationWork as pn, piMessageFromHistoryItem as pr, persistConversationMessageSummaries as pt, loadConversationProjection as q, stripRuntimeTurnContext as qn, getTurnRecord as qt, parseScheduledAutomationRow as r, checkInConversationWork as rn, getThreadStopDecision as rr, recordAuthorizationRequested as rt, scheduledRunId as s, completeConversationWork as sn, getExperimentalFeatures as sr, recordToolExecutionStarted as st, createScheduledAutomation as t, beginConversationResume as tn, decideSubscribedThreadReply as tr, recordAuthenticationLinked as tt, collectEventAutomationMatchKeys as u, getConversation as un, createDurableLocationConfigurationService as ur, hydrateConversationMessages as ut, saveEventAutomation as v, recordAttemptFailure as vn, appendThreadContextMessages as vt, listAutomationVersions as w, startConversationWork as wn, markConversationMessage as wt, eventAutomationRunLimitReason as x, removeActiveConversation as xn, estimateConversationContextTokens as xt, setEventAutomationStatus as y, recordConversationRetry as yn, buildConversationContext as yt, registeredEventTriggerProblems as z, hasRuntimeTurnContext as zn, getConversationPendingAuth as zt };