@sentry/junior 0.266.0 → 0.268.0

package/dist/{tasks-DDT-J3Rf.js → tasks-SB9z-VTU.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 { 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 completeText, f as unwrapCurrentInstruction, p as escapeXml, s as resolveGatewayModel, y as isProviderRetryError } from "./client-C1yDYjoS.js";
+import { i as getChatConfig, n as botConfig } from "./config-DrTeF80T.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-DLSpkSSr.js";
+import { c as parseStoredSlackActor, l as toStoredSlackActor, m as parseSlackMessageTs } from "./actor-CP9K2Idu.js";
+import { B as parseDestination, H as sameDestination, N as addAgentTurnUsage, S as startLocationThread, _ as withConversationEventLock, d as getConversationEventStore, g as createSqlConversationEventStore, h as getSqlExecutor, j as bindProviderConversation, m as getDb, p as getConversationStore } from "./viewer-CpXTGlep.js";
+import { d as juniorDestinations } from "./agent-invocations-C1RNOCs8.js";
+import { d as juniorAutomations, l as juniorAutomationRuns, p as juniorLocationConfigurations, u as juniorAutomationVersions } from "./executor-4vhvsMZJ.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-BgecKva0.js";
+import { n as pluginCatalogRuntime } from "./catalog-runtime-BD9GSpc6.js";
+import { H as startOAuthFlow, In as createPluginLogger, bt as parseSandboxEgressAuthRequiredSignal, cr as createPluginCache, dr as agentsInstructionsUpdatedEvent, fr as authenticationLinkedEvent, p as getPlugins, pn as JUNIOR_THREAD_STATE_TTL_MS, pr as authenticationUnlinkedEvent, t as executeCredentialedEgressRequest, un as sleep$1, ur as JUNIOR_NATIVE_EVENT_NAMESPACE, wt as resolveSandboxEgressProviderForHost, yn as ToolInputError, z as formatProviderLabel } from "./credentialed-lukuD-cc.js";
+import { a as MUTATION_LOCK_TTL_MS, c as withLock, i as getStateAdapter, r as getDefaultRedisStateAdapterFor, s as fenceLock } from "./adapter-04AcD2SO.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) {
@@ -401,7 +401,11 @@ function createDurableLocationConfigurationService(args) {
 * Add new keys here as features graduate from private experiments; remove them
 * once they become stable defaults.
 */
-const EXPERIMENTAL_FEATURES = ["operator-tools", "passive-routing"];
+const EXPERIMENTAL_FEATURES = [
+	"operator-tools",
+	"passive-routing",
+	"user-customization"
+];
 const EXPERIMENTAL_FEATURE_SET = new Set(EXPERIMENTAL_FEATURES);
 let configuredExperimental = {};
 function isExperimentalFeature(value) {
@@ -887,7 +891,8 @@ const SESSION_CONTEXT_SECTION_TAG = "runtime";
 const REQUEST_CONTEXT_SECTION_TAG = {
 	pluginContext: "plugin-context",
 	conversationNotes: "conversation-notes",
-	disabledTools: "disabled-tools"
+	disabledTools: "disabled-tools",
+	userCustomization: "user-customization"
 };
 // src/chat/pi/transcript.ts
 const RUNTIME_TURN_CONTEXT_START = `<${TURN_CONTEXT_TAG}>`;
@@ -1038,7 +1043,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 +1110,1168 @@ 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(),
+	/**
+	* Identity of the input author, resolved at ingress.
+	*
+	* TODO(dcramer): Set this at every ingress after every deployed worker
+	* reads it. This schema is strict, so an older worker rejects the entry.
+	*/
+	authorIdentityId: 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";
@@ -1145,8 +2312,17 @@ async function withTurnCursorMutation(conversationId, turnId, run) {
 	if (!result.acquired) throw new Error(`Could not acquire turn cursor lock for ${turnId}`);
 	return result.value;
 }
-function executionMetricsForTurn(conversation, turnId) {
-	return conversation?.executionMetrics?.runId === turnId ? conversation.executionMetrics : void 0;
+/**
+* Read this Turn's own totals. A newer Turn can own the latest Conversation
+* metrics while this Turn is paused, so fall back to this Turn's metric rows.
+*/
+async function executionMetricsForTurn(conversationStore, conversation, turnId) {
+	if (!conversation) return void 0;
+	if (conversation.executionMetrics?.runId === turnId) return conversation.executionMetrics;
+	return await conversationStore.getRunMetrics({
+		conversationId: conversation.conversationId,
+		runId: turnId
+	});
 }
 /** Keep only keys whose value is defined. */
 function definedProps$1(values) {
@@ -1195,6 +2371,7 @@ const storedTurnSummarySchema = z.object({
 /** Full resume cursor stored for one turn. */
 const storedTurnRecordSchema = z.object({
 	actor: actorSchema.optional(),
+	actorIdentityId: z.string().min(1).optional(),
 	schemaVersion: z.literal(TURN_CURSOR_SCHEMA_VERSION),
 	version: z.number().int().nonnegative(),
 	conversationId: z.string().min(1),
@@ -1216,7 +2393,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(),
@@ -1317,6 +2494,7 @@ function materializeTurnRecord(stored, piProjection, turnStartMessageIndex, runt
 		actors: instructionActors(piProjection.provenance),
 		cumulativeDurationMs: runtimeMetrics?.cumulativeDurationMs ?? 0,
 		...definedProps$1({
+			actorIdentityId: stored.actorIdentityId,
 			channelName: runtimeMetrics?.channelName,
 			credentialSubject: stored.credentialSubject,
 			cumulativeToolCallCount: stored.cumulativeToolCallCount,
@@ -1331,7 +2509,7 @@ function materializeTurnRecord(stored, piProjection, turnStartMessageIndex, runt
 			resultMessageId: stored.resultMessageId,
 			resumedFromSliceId: stored.resumedFromSliceId,
 			surface: stored.surface,
-			traceId: stored.traceId,
+			traceContext: stored.traceContext,
 			turnStartMessageIndex
 		})
 	};
@@ -1358,8 +2536,9 @@ async function materializeStoredTurnRecord(conversationId, turnId, followCurrent
 	const followsReplacement = followCurrentReplacement && (parsed.state === "running" || parsed.state === "paused") && parsed.historyVersion !== void 0 && parsed.historyVersion !== currentHistoryVersion;
 	const piProjection = followsReplacement ? projectConversationEvents(await eventStore.loadCurrentHistory(conversationId), { defaultProfile: botConfig.defaultProfile }) : pinnedProjection;
 	const turnStartMessageIndex = followsReplacement ? 0 : parsed.turnStartSeq === void 0 ? void 0 : piProjection.seqs.filter((seq) => seq <= parsed.turnStartSeq).length;
-	const conversation = await getConversationStore().get({ conversationId });
-	const executionMetrics = executionMetricsForTurn(conversation, turnId);
+	const conversationStore = getConversationStore();
+	const conversation = await conversationStore.get({ conversationId });
+	const executionMetrics = await executionMetricsForTurn(conversationStore, conversation, turnId);
 	return materializeTurnRecord(parsed, piProjection, turnStartMessageIndex, {
 		channelName: conversation?.channelName,
 		cumulativeDurationMs: executionMetrics?.durationMs,
@@ -1390,6 +2569,7 @@ function buildStoredRecord(args) {
 		committedSeq: args.committedSeq,
 		...definedProps$1({
 			actor: args.actor,
+			actorIdentityId: args.actorIdentityId,
 			credentialSubject: args.credentialSubject,
 			cumulativeToolCallCount: args.cumulativeToolCallCount,
 			turnLimitWrappedUp: args.turnLimitWrappedUp,
@@ -1404,7 +2584,7 @@ function buildStoredRecord(args) {
 			resultMessageId: args.resultMessageId,
 			resumedFromSliceId: args.resumedFromSliceId,
 			surface: args.surface,
-			traceId: args.traceId,
+			traceContext: args.traceContext,
 			turnStartSeq: args.turnStartSeq
 		})
 	};
@@ -1468,6 +2648,7 @@ async function updateTurnState(args) {
 			lastProgressAtMs: parsed.lastProgressAtMs,
 			previousVersion: parsed.version,
 			...definedProps$1({
+				actorIdentityId: args.existing.actorIdentityId,
 				credentialSubject: args.existing.credentialSubject,
 				cumulativeToolCallCount: args.existing.cumulativeToolCallCount,
 				turnLimitWrappedUp: args.existing.turnLimitWrappedUp,
@@ -1482,7 +2663,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
 			})
 		})
@@ -1494,8 +2675,9 @@ async function upsertTurnRecord(args) {
 }
 async function upsertTurnRecordLocked(args, fence) {
 	const existingRecord = await getStoredTurnRecord(args.conversationId, args.turnId);
-	const conversation = await (args.conversationStore ?? getConversationStore()).get({ conversationId: args.conversationId });
-	const executionMetrics = executionMetricsForTurn(conversation, args.turnId);
+	const conversationStore = args.conversationStore ?? getConversationStore();
+	const conversation = await conversationStore.get({ conversationId: args.conversationId });
+	const executionMetrics = await executionMetricsForTurn(conversationStore, conversation, args.turnId);
 	const existingDispatchId = existingRecord?.dispatchId ?? (await listTurnSummaries(args.conversationId)).find((summary) => summary.turnId === args.turnId)?.dispatchId;
 	if (existingDispatchId && args.dispatchId && existingDispatchId !== args.dispatchId) throw new Error(`Turn ${args.turnId} dispatchId cannot be changed`);
 	const ttlMs = turnCursorTtlMs(args.state, args.ttlMs);
@@ -1544,6 +2726,7 @@ async function upsertTurnRecordLocked(args, fence) {
 			historyVersion: commit.historyVersion,
 			previousVersion: existingRecord?.version,
 			...definedProps$1({
+				actorIdentityId: existingRecord?.actorIdentityId,
 				credentialSubject: existingRecord?.credentialSubject ?? args.credentialSubject,
 				cumulativeToolCallCount: args.cumulativeToolCallCount ?? existingRecord?.cumulativeToolCallCount,
 				turnLimitWrappedUp: args.turnLimitWrappedUp ?? existingRecord?.turnLimitWrappedUp,
@@ -1559,7 +2742,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
 			})
 		})
@@ -1573,7 +2756,7 @@ async function recordTurnSummaryOwned(args, fence) {
 	const stored = await getStoredTurnRecord(args.conversationId, args.turnId);
 	const conversationStore = args.conversationStore ?? getConversationStore();
 	const conversation = await conversationStore.get({ conversationId: args.conversationId });
-	const executionMetrics = executionMetricsForTurn(conversation, args.turnId);
+	const executionMetrics = await executionMetricsForTurn(conversationStore, conversation, args.turnId);
 	const priorSummary = (await listTurnSummaries(args.conversationId)).find((summary) => summary.turnId === args.turnId);
 	const terminalSummary = priorSummary && (priorSummary.state === "completed" || priorSummary.state === "failed" || priorSummary.state === "abandoned") ? priorSummary : void 0;
 	const terminalRecord = stored && (stored.state === "completed" || stored.state === "failed" || stored.state === "abandoned") ? stored : void 0;
@@ -1728,7 +2911,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 +4448,213 @@ 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/services/turn-session-routing.ts
+async function loadConversationChain(conversationId, conversationStore) {
+	const chain = [];
+	const seen = /* @__PURE__ */ new Set();
+	let cursor = conversationId;
+	while (cursor && !seen.has(cursor)) {
+		seen.add(cursor);
+		const conversation = await conversationStore.get({ conversationId: cursor });
+		if (!conversation) break;
+		chain.push(conversation);
+		cursor = conversation.parentConversationId;
+	}
+	return chain;
+}
+/**
+* Normalize a stored Slack session source against the conversation destination.
+*
+* Does not create channel or thread values from the conversation id.
+*/
+function slackSourceForDestination(args) {
+	if (args.source?.kind !== "slack" || args.source.channelId !== args.destination.channelId) return;
+	const threadTs = args.source.threadTs?.trim();
+	return {
+		kind: "slack",
+		visibility: args.source.visibility ?? "public",
+		teamId: args.source.teamId?.trim() || args.destination.teamId,
+		channelId: args.source.channelId,
+		...threadTs ? { threadTs } : void 0
+	};
+}
+/**
+* Resolve the Conversation Location, Destination, and session Source.
+*
+* Reads parent Conversations when this Conversation has no Destination.
+*/
+async function resolveConversationRouting(args) {
+	const conversationStore = args.conversationStore ?? (await import("./viewer-CpXTGlep.js").then((n) => n.u)).getConversationStore();
+	const chain = await loadConversationChain(args.conversationId, conversationStore);
+	let destination;
+	let source;
+	let location;
+	for (const conversation of chain) {
+		destination ??= conversation.destination;
+		source ??= conversation.sessionSource;
+		location ??= conversation.location;
+		if (destination && source) break;
+	}
+	if (!destination) return;
+	if (destination.platform === "slack") {
+		const slackSource = slackSourceForDestination({
+			destination,
+			source
+		});
+		return {
+			destination,
+			...location ? { location } : void 0,
+			...slackSource ? { source: slackSource } : void 0
+		};
+	}
+	return {
+		destination,
+		...location ? { location } : void 0,
+		...source ? { source } : void 0
+	};
+}
+/** Require the Conversation Destination and Source from SQL. */
+async function resolveTurnSessionRouting(args) {
+	const routing = await resolveConversationRouting(args);
+	if (!routing?.destination || !routing.source) throw new Error(`Conversation ${args.conversationId} is missing durable routing metadata`);
+	return {
+		destination: routing.destination,
+		...routing.location ? { location: routing.location } : void 0,
+		source: routing.source
+	};
+}
 // src/chat/automations/revision.ts
 /** Storage revisions prevent stale edits from replacing newer values. */
 var AutomationConflictError = class extends ToolInputError {
@@ -3407,6 +4797,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 +4813,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 +4866,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 +4874,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 +4985,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 +5250,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 { loadTurnRoute as $, TURN_CONTEXT_TAG as $n, CONVERSATION_WORK_STALE_ENQUEUE_MS as $t, resolveConversationRouting as A, TurnBudgetExceededError as An, upsertConversationMessage as At, registeredEventMatchSchema as B, getUserMessageInstructionText as Bn, clearPendingAuth as Bt, automationVersionOf as C, removeActiveConversation as Cn, estimateConversationContextTokens as Ct, AutomationConflictError as D, steerWebPendingMessages as Dn, normalizeConversationText as Dt, sameDefinitionValue as E, startConversationWork as En, markConversationMessage as Et, eventCatalogEntry as F, isTurnExecutionLimitExceededError as Fn, AuthPausePersistenceError as Ft, requireValidEventTrigger as G, isToolResultError as Gn, saveTurnCheckpoint as Gt, registeredEventTypeSchema as H, instructionTextForProjection as Hn, wasPendingAuthStopped as Ht, eventGuidance as I, persistWithRetry as In, AuthorizationFlowDisabledError as It, loadConnectedMcpProviders as J, retainRuntimeTurnContext as Jn, failTurnRecord as Jt, commitAcceptedReply as K, isToolResultMessage as Kn, abandonTurnRecord as Kt, eventNamespaceSchema as L, extractAssistantText as Ln, AuthorizationPauseError as Lt, CORE_EVENT_NAMESPACE as M, TurnToolCallLimitExceededError as Mn, PluginCredentialFailureError as Mt, automationEventCatalog as N, buildTurnErrorResponse as Nn, createPluginAuthOrchestration as Nt, automationRevision as O, stopConversationWork as On, recordDeliveredAssistantMessage as Ot, describeRegisteredEventTrigger as P, createTurnLimitGate as Pn, authorizationId as Pt, loadTurnProjection as Q, SESSION_CONTEXT_SECTION_TAG as Qn, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS as Qt, eventWatchUnavailable as R, getPiMessageRole as Rn, abandonReplacedPendingAuth as Rt, automationDefinition as S, releaseConversationWork as Sn, createConversationMemoryService as St, readAutomationVersion as T, requestConversationWork as Tn, isHumanConversationMessage as Tt, registeredResourceTypeSchema as U, isAssistantMessage as Un, continuableMessages as Ut, registeredEventTriggerProblems as V, hasRuntimeTurnContext as Vn, getConversationPendingAuth as Vt, requireEventIdentifier as W, isContinuablePiBoundary as Wn, loadTurnCheckpoint as Wt, loadLastModelProfile as X, trimTrailingAssistantMessages as Xn, listTurnSummaries as Xt, loadConversationProjection as Y, stripRuntimeTurnContext as Yn, getTurnRecord as Yt, loadProjection as Z, REQUEST_CONTEXT_SECTION_TAG as Zn, recordTurnSummary as Zt, parseEventAutomationRow as _, isInvalidConversationRecordError as _n, setConfigDefaults as _r, settleConversationTitleWork as _t, saveScheduledAutomation as a, checkInConversationWork as an, getThreadStopDecision as ar, recordAuthorizationRequested as at, admitEventAutomationRun as b, recordAttemptFailure as bn, appendThreadContextMessages as bt, withScheduledAutomationLock as c, completeConversationStop as cn, getAgentContextInputLimitTokens as cr, recordSubscribedReplyRoute as ct, createEventAutomation as d, drainConversationMailbox as dn, setExperimentalFeatures as dr, appendConversationMessages as dt, ackMessages as en, buildDeterministicAssistantMessageId as er, openConversationProjection as et, deleteEventAutomation as f, getConversation as fn, createDurableLocationConfigurationService as fr, hydrateConversationMessages as ft, listEventAutomationsForTeam as g, isFinalAttempt as gn, getConfigDefaults as gr, resolveConversationTitle as gt, listDeletedEventAutomationsCreatedBy as h, hasRunnableConversationWork as hn, piMessageFromHistoryItem as hr, persistConversationMessageSummaries as ht, readScheduledAutomation as i, cancelHumanFacingPendingMessages as in, getSubscribedReplyPreflightDecision as ir, recordAuthorizationCompleted as it, resolveTurnSessionRouting as j, TurnSliceLimitExceededError as jn, createPluginEgress as jt, requireAutomationRevision as k, TURN_LIMIT_DISABLED_REASON as kn, turnHasReply as kt, blockEventAutomation as l, completeConversationWork as ln, getExperimentalFeatures as lr, recordToolExecutionStarted as lt, getEventAutomation as m, hasConversationStop as mn, historyItemFromPiMessage as mr, projectConversationMessages as mt, listScheduledAutomationsForTeam as n, appendInboundMessage as nn, SubscribedReplyReason as nr, recordAttachmentsDelivered as nt, saveScheduledAutomationInLock as o, clearConsumedConversationWake as on, estimateTextTokens as or, recordGuardianActionReviewed as ot, findMatchingEventAutomations as p, getConversationWorkState as pn, configValueSchema as pr, persistConversationMessages as pt, commitMessages as q, normalizeToolNameFromResult as qn, completeTurnRecord as qt, parseScheduledAutomationRow as r, beginConversationResume as rn, decideSubscribedThreadReply as rr, recordAuthenticationLinked as rt, scheduledRunId as s, clearExpiredConversationLease as sn, getAgentContextCompactionTriggerTokens as sr, recordMcpProviderConnected as st, createScheduledAutomation as t, appendExclusiveInboundMessage as tn, buildDeterministicTurnId as tr, recordAgentsInstructionsUpdated as tt, collectEventAutomationMatchKeys as u, deadLetterAttempt as un, isExperimentalFeatureEnabled as ur, recordTurnRoute as ut, saveEventAutomation as v, listActiveConversationIds as vn, fallbackShortTitle as vt, listAutomationVersions as w, requestAnotherSlice as wn, getConversationMessageSlackTs as wt, eventAutomationRunLimitReason as x, recordConversationRetry as xn, buildConversationContext as xt, setEventAutomationStatus as y, markConversationWorkEnqueued as yn, resolveTaskTitle as yt, hasEventCatalogEntries as z, getTerminalAssistantMessages as zn, canReusePendingAuthLink as zt };