@sentry/junior 0.266.0 → 0.268.0

package/dist/{session-stop-tZOw9AJD.js → session-stop-Dam1EI7B.js}

@@ -1,19 +1,19 @@
 import { t as __exportAll } from "./rolldown-runtime-nwUcYXjP.js";
-import { $t as isToolResultMessage, Qt as isToolResultError, Xt as isAssistantMessage, en as normalizeToolNameFromResult } from "./tasks-DDT-J3Rf.js";
-import { n as botConfig } from "./config-C0UwYqDK.js";
-import { f as logException, m as logWarn, p as logInfo } from "./logging-Ce0mXZ8J.js";
-import { d as getConversationStore, p as getSqlExecutor } from "./viewer-BpE6Z3qf.js";
-import { s as juniorConversations } from "./agent-invocations-CxKldAeB.js";
-import "./executor-TnWbvL09.js";
-import { h as credentialSubjectSchema } from "./registry-1BEIPdbT.js";
-import { Yt as verifyTimerWatchCredentialSubject, ln as JUNIOR_THREAD_STATE_TTL_MS, mn as ToolInputError, p as getPlugins, vt as postSlackMessage } from "./credentialed-enF5Bf3y.js";
-import { r as getStateAdapter } from "./adapter-eRFA_naf.js";
-import { r as EVENT_AUTHOR_ID } from "./prompt-BcCGlmg2.js";
-import { r as sanitizeAssistantText } from "./assistant-reply-UyzAfZQo.js";
-import { r as appendAndEnqueueInboundMessage } from "./store-FALy-JQb.js";
+import { F as eventCatalogEntry, Gn as isToolResultError, I as eventGuidance, Kn as isToolResultMessage, M as CORE_EVENT_NAMESPACE, Un as isAssistantMessage, qn as normalizeToolNameFromResult } from "./tasks-SB9z-VTU.js";
+import { n as botConfig } from "./config-DrTeF80T.js";
+import { h as logWarn, m as logInfo, p as logException } from "./logging-DLSpkSSr.js";
+import { h as getSqlExecutor, p as getConversationStore } from "./viewer-CpXTGlep.js";
+import { s as juniorConversations } from "./agent-invocations-C1RNOCs8.js";
+import "./executor-4vhvsMZJ.js";
+import { h as credentialSubjectSchema } from "./registry-BgecKva0.js";
+import { $t as verifyTimerWatchCredentialSubject, G as normalizeSlackReplyMarkdown, U as escapeSlackMrkdwnText, W as formatSlackLink, Yn as buildSentryConversationUrl, hn as getDashboardObjectIconLink, l as getPluginSlackConversationLink, mn as getDashboardConversationLink, p as getPlugins, pn as JUNIOR_THREAD_STATE_TTL_MS, tt as postSlackMessage, yn as ToolInputError } from "./credentialed-lukuD-cc.js";
+import { i as getStateAdapter } from "./adapter-04AcD2SO.js";
+import { r as EVENT_AUTHOR_ID } from "./prompt-BW9jFsqZ.js";
+import { i as sanitizeAssistantText, t as getInterruptionMarker } from "./interruption-marker-CkncDT8d.js";
+import { r as appendAndEnqueueInboundMessage } from "./store-zPEoJPBB.js";
 import { z } from "zod";
 import { eq, inArray } from "drizzle-orm";
-import { describeEventTrigger, eventMatchFieldsSchema, eventMatchSchema, eventTriggerProblems, normalizeEventIdentifier, objectTypeSchema } from "@sentry/junior-plugin-api";
+import { eventMatchFieldsSchema, objectFactFields, objectPresentation, objectTypeSchema } from "@sentry/junior-plugin-api";
 // src/chat/automation-result.ts
 /**
 * Automation run result.
@@ -48,6 +48,17 @@ function deliversFinalText(dispatch) {
 	return dispatch?.outcomes?.length !== 0 && !dispatch?.declaresResult;
 }
 /**
+* Return whether the runtime may post a failure reply or a status notice,
+* such as an auth prompt, for a run outside `finishedRunReply`. The rule is
+* the same as for final text. A chat Turn may post, also in a thread that an
+* Automation Conversation owns. A dispatch with no outcomes posts nothing. An
+* Automation run posts only a declared message; its failed execution shows on
+* the Automation.
+*/
+function postsRunNotices(dispatch) {
+	return deliversFinalText(dispatch);
+}
+/**
 * Return the text to post after a run ends, if any. A chat Turn already
 * delivered a successful reply, so it posts only its failure reply. An
 * Automation run posts only a declared message. It never posts a failure
@@ -271,6 +282,467 @@ async function recordFinishedTurnForAutomatedLimit(args) {
 		state: args.state
 	});
 }
+// src/chat/slack/automation-card.ts
+function preview(text, length) {
+	const compact = text.replace(/\s+/g, " ").trim();
+	return compact.length > length ? `${compact.slice(0, length - 1)}…` : compact;
+}
+/** Show an Automation as a native Work Object, not an operation receipt. */
+function renderSlackAutomationCard(card) {
+	const title = preview(card.title, 160);
+	const iconUrl = getDashboardObjectIconLink("workflow");
+	const trigger = preview(card.trigger, 500);
+	const warning = card.warning ? preview(card.warning, 500) : null;
+	const text = [
+		"Automation",
+		card.url ? formatSlackLink(card.url, title) : escapeSlackMrkdwnText(title),
+		escapeSlackMrkdwnText(trigger),
+		warning ? escapeSlackMrkdwnText(warning) : null
+	].filter(Boolean).join("\n");
+	if (!card.url) return {
+		entity: null,
+		text
+	};
+	return {
+		text,
+		entity: {
+			entity_type: "slack#/entities/item",
+			external_ref: {
+				id: card.id,
+				type: "automation"
+			},
+			url: card.url,
+			entity_payload: {
+				attributes: {
+					title: { text: title },
+					display_type: "Automation",
+					product_icon: iconUrl ? {
+						url: iconUrl,
+						alt_text: "Automation"
+					} : void 0
+				},
+				custom_fields: [{
+					key: "trigger",
+					label: "When",
+					type: "string",
+					value: trigger,
+					long: true
+				}, ...warning ? [{
+					key: "warning",
+					label: "Needs attention",
+					type: "string",
+					value: warning,
+					long: true
+				}] : []]
+			}
+		}
+	};
+}
+// src/chat/slack/object-card.ts
+function descriptionPreview(value) {
+	const text = value?.replace(/\r\n/g, "\n").trim() ?? "";
+	const preview = text.split("\n").slice(0, 6).join("\n").slice(0, 500);
+	return preview.length < text.length ? `${preview.slice(0, 499).trimEnd()}…` : preview;
+}
+/** Render a compact Task or Item preview, or the saved facts for its detail panel. */
+function renderSlackObjectCard(card, conversationId, surface = "preview") {
+	if (card.objectType === "automation" && card.plugin === "junior") return renderSlackAutomationCard({
+		id: card.key,
+		title: card.title,
+		url: card.url,
+		trigger: card.trigger ?? "",
+		warning: card.warning ?? null
+	});
+	const presentation = objectPresentation(card);
+	const type = card.displayType ?? presentation.label;
+	const iconUrl = getDashboardObjectIconLink(presentation.icon);
+	const title = card.title.slice(0, 160);
+	const details = surface === "details";
+	const deployment = card.objectType === "deployment" || card.objectType === "item" && card.facts?.type === "deployment";
+	const calendarEvent = card.objectType === "calendar_event";
+	const status = details || deployment || calendarEvent ? card.status : void 0;
+	const warning = details || deployment ? card.warning : void 0;
+	const facts = objectFactFields(card.facts).filter((field) => details || calendarEvent || deployment && field.key === "environment");
+	const description = details ? card.description?.trim() ?? "" : calendarEvent ? "" : descriptionPreview(card.description);
+	const text = [
+		escapeSlackMrkdwnText(type),
+		card.url ? formatSlackLink(card.url, title) : escapeSlackMrkdwnText(title),
+		escapeSlackMrkdwnText(card.label),
+		status ? escapeSlackMrkdwnText(status) : null,
+		description ? escapeSlackMrkdwnText(description) : null,
+		warning ? escapeSlackMrkdwnText(`Needs attention: ${warning}`) : null,
+		...facts.map((field) => escapeSlackMrkdwnText(`${field.label}: ${field.value}`))
+	].filter(Boolean).join("\n");
+	if (!card.url) return {
+		entity: null,
+		text
+	};
+	const task = card.objectType === "task";
+	const attributes = {
+		title: { text: title },
+		display_id: card.label,
+		display_type: type,
+		product_icon: iconUrl ? {
+			url: iconUrl,
+			alt_text: `${type}${status ? `: ${status}` : ""}`
+		} : void 0,
+		product_name: card.plugin
+	};
+	const customFields = [
+		...description ? [{
+			key: "description",
+			label: "Description",
+			type: "string",
+			value: description,
+			long: true,
+			format: "markdown"
+		}] : [],
+		...facts.map((field) => ({
+			...field,
+			type: "string"
+		})),
+		...warning ? [{
+			key: "warning",
+			label: "Needs attention",
+			type: "string",
+			value: warning
+		}] : []
+	];
+	return {
+		text,
+		entity: {
+			...task ? {
+				entity_type: "slack#/entities/task",
+				entity_payload: {
+					attributes,
+					display_order: [...status ? ["status"] : [], ...customFields.map((field) => field.key)],
+					fields: status ? { status: { value: status } } : void 0,
+					custom_fields: customFields
+				}
+			} : {
+				entity_type: "slack#/entities/item",
+				entity_payload: {
+					attributes,
+					display_order: [...status ? ["status"] : [], ...customFields.map((field) => field.key)],
+					custom_fields: [...status ? [{
+						key: "status",
+						label: "Status",
+						type: "string",
+						value: status
+					}] : [], ...customFields]
+				}
+			},
+			external_ref: {
+				id: Buffer.from(JSON.stringify([
+					conversationId,
+					card.plugin,
+					card.key
+				]), "utf8").toString("base64url"),
+				type: "annotation"
+			},
+			url: card.url
+		}
+	};
+}
+// src/chat/slack/cards.ts
+/** Select the Slack object renderer for a built-in card. */
+function renderSlackCard(card, conversationId) {
+	switch (card.kind) {
+		case "object": return renderSlackObjectCard(card, conversationId);
+		case "automation": return renderSlackAutomationCard(card);
+	}
+}
+// src/chat/slack/footer.ts
+/** Render compact reply attribution for the Slack footer. */
+function formatReplyAttribution(attribution) {
+	return attribution.detail ? `${attribution.label} · ${attribution.detail}` : attribution.label;
+}
+/**
+* Build the compact conversation footer for visible Slack reply surfaces.
+*
+* Detailed turn metrics stay in the dashboard instead of Slack-visible copy.
+*/
+function buildSlackReplyFooter(args) {
+	const items = [];
+	const conversationId = args.conversationId?.trim();
+	if (conversationId) {
+		const idItem = {
+			label: "ID",
+			value: conversationId
+		};
+		const conversationUrl = getPluginSlackConversationLink(conversationId)?.url ?? getDashboardConversationLink(conversationId) ?? buildSentryConversationUrl(conversationId);
+		if (conversationUrl) idItem.url = conversationUrl;
+		items.push(idItem);
+	}
+	return items.length > 0 || args.replyAttribution ? {
+		...args.replyAttribution ? { attribution: args.replyAttribution } : void 0,
+		items
+	} : void 0;
+}
+/** Build Slack blocks for a reply chunk using the Slack-flavored markdown block for the body. */
+function buildSlackReplyBlocks(text, footer) {
+	const blocks = text.trim() ? [{
+		type: "markdown",
+		text
+	}] : [];
+	if (footer && (footer.attribution || footer.items.length > 0)) {
+		const attributionElements = footer.attribution ? [{
+			type: "plain_text",
+			text: formatReplyAttribution(footer.attribution)
+		}] : [];
+		blocks.push({
+			type: "context",
+			elements: [...attributionElements, ...footer.items.map((item) => ({
+				type: "mrkdwn",
+				text: item.url ? `*${escapeSlackMrkdwnText(item.label)}:* ${formatSlackLink(item.url, item.value)}` : `*${escapeSlackMrkdwnText(item.label)}:* ${escapeSlackMrkdwnText(item.value)}`
+			}))]
+		});
+	}
+	return blocks.length ? blocks : void 0;
+}
+// src/chat/slack/output.ts
+const MAX_INLINE_CHARS = 2200;
+const MAX_INLINE_LINES = 45;
+const CONTINUED_MARKER = "\n\n[Continued below]";
+function countSlackLines(text) {
+	if (!text) return 0;
+	return text.split("\n").length;
+}
+function fitsInlineBudget(text, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
+	return text.length <= maxChars && countSlackLines(text) <= maxLines;
+}
+function findSplitIndex(text, maxChars) {
+	if (text.length <= maxChars) return text.length;
+	const bounded = text.slice(0, maxChars);
+	const newlineIndex = bounded.lastIndexOf("\n");
+	if (newlineIndex > 0) return newlineIndex;
+	const spaceIndex = bounded.lastIndexOf(" ");
+	if (spaceIndex > 0) return spaceIndex;
+	return maxChars;
+}
+function splitByLineBudget(text, maxLines) {
+	if (maxLines <= 0) return "";
+	const lines = text.split("\n");
+	if (lines.length <= maxLines) return text;
+	return lines.slice(0, maxLines).join("\n");
+}
+function reserveInlineBudgetForSuffix(suffix, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
+	return {
+		maxChars: Math.max(1, maxChars - suffix.length),
+		maxLines: Math.max(1, maxLines - Math.max(0, countSlackLines(suffix) - 1))
+	};
+}
+function forceSplitBudget(text, budget) {
+	const lineCount = countSlackLines(text);
+	return {
+		maxChars: text.length <= budget.maxChars ? Math.max(1, text.length - 1) : budget.maxChars,
+		maxLines: lineCount <= budget.maxLines ? Math.max(1, lineCount - 1) : budget.maxLines
+	};
+}
+function getFenceContinuation(text) {
+	let open;
+	for (const line of text.split("\n")) {
+		const trimmed = line.trimStart();
+		const openerMatch = trimmed.match(/^(`{3,}|~{3,})(.*)$/);
+		if (!openerMatch?.[1]) continue;
+		if (!open) {
+			open = {
+				fence: openerMatch[1],
+				openerLine: trimmed
+			};
+			continue;
+		}
+		if (new RegExp(`^${open.fence}\\s*$`).test(trimmed)) open = void 0;
+	}
+	if (!open) return null;
+	return {
+		closeSuffix: text.endsWith("\n") ? open.fence : `\n${open.fence}`,
+		reopenPrefix: `${open.openerLine}\n`
+	};
+}
+function appendSlackSuffix(text, marker) {
+	return `${text}${getFenceContinuation(text)?.closeSuffix ?? ""}${marker}`;
+}
+function stripTrailingContinuationMarker(text) {
+	return text.endsWith(CONTINUED_MARKER) ? text.slice(0, -19) : text;
+}
+function takeSlackContinuationChunk(text, budget) {
+	let { prefix, rest } = takeSlackInlinePrefix(text, budget);
+	if (!rest) ({prefix, rest} = takeSlackInlinePrefix(text, forceSplitBudget(text, budget)));
+	let carryover = rest ? getFenceContinuation(prefix) : null;
+	if (!carryover) return {
+		prefix,
+		rest
+	};
+	const carryoverBudget = reserveInlineBudgetForSuffix(`${carryover.closeSuffix}${CONTINUED_MARKER}`);
+	({prefix, rest} = takeSlackInlinePrefix(text, carryoverBudget));
+	if (!rest) ({prefix, rest} = takeSlackInlinePrefix(text, forceSplitBudget(text, carryoverBudget)));
+	carryover = rest ? getFenceContinuation(prefix) : null;
+	if (!carryover) return {
+		prefix,
+		rest
+	};
+	return {
+		prefix,
+		rest: `${carryover.reopenPrefix}${rest}`
+	};
+}
+/** Return the first continuation-safe chunk plus any remaining text. */
+function takeSlackContinuationPrefix(text, options) {
+	const budget = {
+		maxChars: options?.maxChars ?? getSlackContinuationBudget().maxChars,
+		maxLines: options?.maxLines ?? getSlackContinuationBudget().maxLines
+	};
+	const { prefix, rest } = (() => {
+		if (options?.forceSplit) return takeSlackContinuationChunk(text, budget);
+		const initial = takeSlackInlinePrefix(text, budget);
+		return initial.rest ? takeSlackContinuationChunk(text, budget) : initial;
+	})();
+	return {
+		prefix,
+		renderedPrefix: rest ? appendSlackSuffix(prefix, CONTINUED_MARKER) : prefix,
+		rest
+	};
+}
+/**
+* Take the largest Slack-safe inline prefix from `text` under the configured
+* character and line budgets. Returns the consumed prefix plus remaining text.
+*/
+function takeSlackInlinePrefix(text, options) {
+	const maxChars = options?.maxChars ?? MAX_INLINE_CHARS;
+	const maxLines = options?.maxLines ?? MAX_INLINE_LINES;
+	const normalized = text.replace(/\r\n?/g, "\n");
+	if (!normalized) return {
+		prefix: "",
+		rest: ""
+	};
+	if (fitsInlineBudget(normalized, maxChars, maxLines)) return {
+		prefix: normalized,
+		rest: ""
+	};
+	const lineBounded = splitByLineBudget(normalized, maxLines);
+	const cutIndex = findSplitIndex(lineBounded, maxChars);
+	const prefix = lineBounded.slice(0, cutIndex).trimEnd();
+	if (prefix) return {
+		prefix,
+		rest: normalized.slice(prefix.length).trimStart()
+	};
+	const hardPrefix = normalized.slice(0, Math.max(1, maxChars)).trimEnd();
+	return {
+		prefix: hardPrefix || normalized.slice(0, Math.max(1, maxChars)),
+		rest: normalized.slice(hardPrefix.length || Math.max(1, maxChars)).trimStart()
+	};
+}
+/**
+* Split a normalized Slack reply into multiple inline-safe thread messages.
+*
+* Replies split across more than two messages receive explicit continuation
+* markers on non-final chunks. When
+* `interrupted` is true, the final chunk receives an interruption marker.
+*/
+function splitSlackReplyText(text, options) {
+	const normalized = normalizeSlackReplyMarkdown(text);
+	if (!normalized) return [];
+	const chunks = [];
+	const continuationBudget = reserveInlineBudgetForSuffix(CONTINUED_MARKER);
+	let remaining = normalized;
+	while (remaining) {
+		if (options?.interrupted ? fitsInlineBudget(appendSlackSuffix(remaining, getInterruptionMarker())) : fitsInlineBudget(remaining)) {
+			chunks.push(options?.interrupted ? appendSlackSuffix(remaining, getInterruptionMarker()) : remaining);
+			break;
+		}
+		const { renderedPrefix, rest } = takeSlackContinuationPrefix(remaining, {
+			...continuationBudget,
+			forceSplit: true
+		});
+		chunks.push(renderedPrefix);
+		remaining = rest;
+	}
+	if (chunks.length === 2) chunks[0] = stripTrailingContinuationMarker(chunks[0] ?? "");
+	return chunks;
+}
+/**
+* Reserve enough inline budget for a continuation suffix on the current chunk.
+*/
+function getSlackContinuationBudget() {
+	return reserveInlineBudgetForSuffix(CONTINUED_MARKER);
+}
+// src/chat/slack/reply.ts
+/**
+* Resolve where a Turn posts in Slack.
+*
+* The channel is always the Destination channel. The thread comes from the
+* Turn Source, then the Conversation Location, then the Destination, and each
+* one counts only when it names that channel. Do not derive the target from
+* the Conversation id: an Automation or Watch Conversation can own a Slack
+* thread, and its id is not a Slack thread id.
+*/
+function resolveSlackReplyTarget(args) {
+	const { channelId } = args.destination;
+	const sourceThreadTs = args.source?.kind === "slack" && args.source.channelId === channelId ? args.source.threadTs : void 0;
+	const locationThreadTs = args.location?.provider === "slack" && args.location.channelId === channelId ? args.location.threadTs : void 0;
+	const threadTs = sourceThreadTs ?? locationThreadTs ?? args.destination.threadTs;
+	return {
+		channelId,
+		...threadTs ? { threadTs } : void 0
+	};
+}
+/**
+* Send one destination-visible Slack reply.
+*
+* Chunks oversized text, builds compact attribution and conversation footer
+* context, and posts through the shared Slack outbound boundary.
+*/
+async function sendSlackReply(args) {
+	const posts = splitSlackReplyText(args.text).map((text) => ({
+		text,
+		cards: []
+	}));
+	const cards = (args.cards ?? []).map((card) => renderSlackCard(card, args.conversationId));
+	for (let index = 0; index < cards.length; index += 5) {
+		const group = cards.slice(index, index + 5);
+		const lastPost = posts.at(-1);
+		if (index === 0 && lastPost) lastPost.cards = group;
+		else posts.push({
+			text: "",
+			cards: group
+		});
+	}
+	const footer = buildSlackReplyFooter({
+		conversationId: args.conversationId,
+		replyAttribution: args.replyAttribution
+	});
+	const messageTs = [];
+	let threadTs = args.threadTs;
+	for (const [index, post] of posts.entries()) {
+		const { text, cards } = post;
+		const isFinalChunk = index === posts.length - 1;
+		const blocks = buildSlackReplyBlocks(text, void 0) ?? [];
+		for (const card of cards) if (!card.entity) blocks.push({
+			type: "section",
+			text: {
+				type: "mrkdwn",
+				text: card.text
+			}
+		});
+		if (isFinalChunk || !text.trim()) blocks.push(...buildSlackReplyBlocks("", footer) ?? []);
+		const entities = cards.flatMap((card) => card.entity ? [card.entity] : []);
+		const accessibleText = [text, ...cards.map((card) => card.text)].filter(Boolean).join("\n\n");
+		const fallbackText = isFinalChunk && args.replyAttribution ? `${accessibleText}\n\n${escapeSlackMrkdwnText(formatReplyAttribution(args.replyAttribution))}` : accessibleText;
+		const response = await postSlackMessage({
+			channelId: args.channelId,
+			threadTs,
+			text: fallbackText,
+			...blocks.length ? { blocks } : void 0,
+			...entities.length ? { entities } : void 0
+		});
+		if (response.ts) {
+			messageTs.push(response.ts);
+			threadTs ??= response.ts;
+		}
+	}
+	return messageTs;
+}
 // src/chat/slack/automated-turn-limit-notice.ts
 /**
 * Pause notice for the consecutive automated-turn limit.
@@ -301,10 +773,14 @@ async function postAutomatedTurnLimitNoticeForConversation(args) {
 			});
 			return false;
 		}
-		await postSlackMessage({
-			channelId: location.channelId,
-			text: buildAutomatedTurnLimitResponse({ maxTurns: args.maxTurns }),
-			...args.threadTs ? { threadTs: args.threadTs } : location.threadTs ? { threadTs: location.threadTs } : void 0
+		await sendSlackReply({
+			...resolveSlackReplyTarget({
+				destination: location,
+				location,
+				source: args.source
+			}),
+			conversationId: args.conversationId,
+			text: buildAutomatedTurnLimitResponse({ maxTurns: args.maxTurns })
 		});
 		return true;
 	} catch (error) {
@@ -323,7 +799,7 @@ async function maybePostAutomatedTurnLimitNotice(args) {
 		conversationId: args.conversationId,
 		maxTurns: args.maxTurns,
 		nowMs: args.nowMs,
-		threadTs: args.threadTs
+		source: args.source
 	});
 }
 // src/chat/task-input.ts
@@ -373,7 +849,7 @@ function renderTaskInput(args) {
 		"This is a task, not a message from a person.",
 		"",
 		...about ? [`About: ${oneLine(about)}`] : [],
-		...creator ? [`Created by: ${oneLine(creator)}. "Me" and "my" in the instructions mean this person: mention them in the message. If the instructions do not say "me" or "my", do not mention this person.`] : [],
+		...creator ? [`Created by: ${oneLine(creator)}. This person is the Automation creator. "The Automation creator", "me", and "my" in the instructions mean this person. Where the instructions refer to this person, write this mention in the message. If they do not, do not mention this person.`] : [],
 		...people.length > 0 ? [`People involved: ${people.join(", ")}`] : [],
 		...args.doneBy ? [doneByLine(args.doneBy, people)] : [],
 		`Instructions: ${instructions}`
@@ -439,106 +915,6 @@ function renderTaskBatchInput(args) {
 function joinMailboxText(messages) {
 	return messages.map((message) => message.input.text.trim()).filter(Boolean).join("\n\n");
 }
-// src/chat/events/catalog.ts
-/** Core-owned event namespace. Not a plugin publisher. */
-const CORE_EVENT_NAMESPACE = "junior";
-/** True when the catalog has any enabled registration. */
-function hasEventCatalogEntries(catalog) {
-	return Object.keys(catalog).length > 0;
-}
-/**
-* 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);
-		return resourceTypes.length > 0 ? [[namespace, {
-			...registration,
-			resourceTypes
-		}]] : [];
-	}));
-}
-/** 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 registered resource type and event type. */
-function eventGuidance(catalog, namespace, resourceType, eventType) {
-	return catalog[namespace]?.resourceTypes.find((candidate) => candidate.type === resourceType)?.guidance?.[eventType];
-}
-/** 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]?.resourceTypes ?? [], 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]?.resourceTypes ?? [], 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 without repeated
-* list values.
-*/
-function requireValidEventTrigger(catalog, selection, target) {
-	const problems = registeredEventTriggerProblems(catalog, selection, { inputKeys: true });
-	if (problems.length > 0) {
-		const resource = `${catalog[selection.namespace]?.displayName ?? selection.namespace} ${selection.resourceType.replaceAll("_", " ")}`;
-		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(selection.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/sandbox/snapshot/events.ts
 const WORKSPACE_SNAPSHOT_NAMESPACE = CORE_EVENT_NAMESPACE;
 const WORKSPACE_SNAPSHOT_RESOURCE_TYPE = "workspace_snapshot";
@@ -556,12 +932,18 @@ function workspaceSnapshotEvents() {
 		resourceTypes: [{
 			type: WORKSPACE_SNAPSHOT_RESOURCE_TYPE,
 			supportedEvents: [WORKSPACE_SNAPSHOT_READY_EVENT, WORKSPACE_SNAPSHOT_FAILED_EVENT],
-			suggestedEvents: [],
-			guidance: {
-				[WORKSPACE_SNAPSHOT_READY_EVENT]: "Call switchWorkspace again with the same Workspace name. Do not create another watch when switchWorkspace already returned a subscription.",
-				[WORKSPACE_SNAPSHOT_FAILED_EVENT]: "Report the snapshot failure. Do not keep waiting for this Workspace unless the user asks to retry."
-			}
+			suggestedEvents: []
 		}],
+		events: {
+			[WORKSPACE_SNAPSHOT_READY_EVENT]: {
+				reach: "resource",
+				guidance: "Call switchWorkspace again with the same Workspace name. Do not create another watch when switchWorkspace already returned a subscription."
+			},
+			[WORKSPACE_SNAPSHOT_FAILED_EVENT]: {
+				reach: "resource",
+				guidance: "Report the snapshot failure. Do not keep waiting for this Workspace unless the user asks to retry."
+			}
+		},
 		limits: { [WORKSPACE_SNAPSHOT_RESOURCE_TYPE]: { automation: false } }
 	};
 }
@@ -630,9 +1012,12 @@ function slackChannelMessageEvents() {
 			},
 			supportedEvents: [MESSAGE_POSTED_EVENT],
 			suggestedEvents: [],
-			matchFields: CHANNEL_MESSAGE_MATCH_FIELDS,
-			guidance: { [MESSAGE_POSTED_EVENT]: "A person or bot posted a new top-level message in this channel. A bot post runs the automation only when match names the bot in userId. A reply goes in that message's thread. If the instructions do not apply to this message, end with no action." }
+			matchFields: CHANNEL_MESSAGE_MATCH_FIELDS
 		}],
+		events: { [MESSAGE_POSTED_EVENT]: {
+			reach: "resource",
+			guidance: "A person or bot posted a new top-level message in this channel. A bot post runs the automation only when match names the bot in userId. A reply goes in that message's thread. If the instructions do not apply to this message, end with no action."
+		} },
 		limits: { [CHANNEL_RESOURCE_TYPE]: {
 			watch: false,
 			watchUnavailableMessage: "Slack channel messages can trigger only an event automation in that channel. Use createEventAutomation."
@@ -689,12 +1074,16 @@ function slackChannelMessageEvent(input) {
 /**
 * Decide whether a channel-message Event may run one automation.
 *
+* A message runs only automations that post in its own channel, so private
+* channel text cannot reach another channel. The trigger identifier already
+* names that channel, and this check keeps the rule when it does not.
 * A bot post runs only automations whose match names its author in `userId`.
 * Bots can post often and would use up the run limit of every other
 * automation in the channel.
 */
 function slackChannelMessageRunsAutomation(event, automation) {
 	if (event.namespace !== "slack") return true;
+	if (event.data?.channelId !== automation.destination.channelId) return false;
 	if (event.data?.postedByBot !== true) return true;
 	return automation.trigger.match?.userId !== void 0;
 }
@@ -715,13 +1104,17 @@ function slackChannelMessageReplyThreadTs(event) {
 function getEventCatalog() {
 	const snapshot = workspaceSnapshotEvents();
 	const catalog = {
-		[CORE_EVENT_NAMESPACE]: {
+		[CORE_EVENT_NAMESPACE]: eventCatalogEntry({
 			displayName: botConfig.userName,
 			resourceTypes: [...snapshot.resourceTypes, {
 				type: "timer",
 				supportedEvents: ["timer.fired"],
 				suggestedEvents: []
 			}],
+			events: {
+				...snapshot.events,
+				"timer.fired": { reach: "resource" }
+			},
 			limits: {
 				...snapshot.limits,
 				timer: {
@@ -730,20 +1123,20 @@ function getEventCatalog() {
 					watchUnavailableMessage: "Use watchTimer to create a timer Watch."
 				}
 			}
-		},
-		[SLACK_EVENT_NAMESPACE]: {
+		}),
+		[SLACK_EVENT_NAMESPACE]: eventCatalogEntry({
 			...slackChannelMessageEvents(),
 			displayName: "Slack"
-		}
+		})
 	};
 	for (const plugin of getPlugins()) {
 		const registration = plugin.events;
 		if (!registration || registration.isEnabled?.() === false) continue;
 		if (plugin.manifest.name === "junior" || plugin.manifest.name === "slack") throw new Error(`Plugin "${plugin.manifest.name}" cannot register events; that namespace is reserved for core events`);
-		catalog[plugin.manifest.name] = {
+		catalog[plugin.manifest.name] = eventCatalogEntry({
 			...registration,
 			displayName: plugin.manifest.displayName
-		};
+		});
 	}
 	return catalog;
 }
@@ -769,7 +1162,7 @@ const eventTaskFactsSchema = z.object({
 * contract. Stable delivery rules live in runtime and docs, not this prompt.
 */
 function eventTaskFacts(subscription, event, people = [], doneBy) {
-	const guidance = [eventGuidance(getEventCatalog(), event.namespace, subscription.resourceType, event.eventType), subscription.guidance?.[event.eventType]].filter((text) => Boolean(text?.trim())).join(" ");
+	const guidance = [eventGuidance(getEventCatalog(), event.namespace, event.eventType), subscription.guidance?.[event.eventType]].filter((text) => Boolean(text?.trim())).join(" ");
 	return {
 		about: subscription.label,
 		instructions: subscription.intent,
@@ -996,4 +1389,4 @@ async function skipInputBeforeConversationStop(context) {
 	await context.attempt.ack();
 	return { status: "completed" };
 }
-export { requireEventIdentifier as A, finishedRunReply as B, eventGuidance as C, registeredEventMatchSchema as D, hasEventCatalogEntries as E, recordFinishedTurnForAutomatedLimit as F, remindMissingAutomationResult as H, resetAutomatedTurnLimit as I, FINISH_AUTOMATION_RUN_TOOL_NAME as L, joinMailboxText as M, renderTaskInput as N, registeredEventTypeSchema as O, maybePostAutomatedTurnLimitNotice as P, automationResultSchema as R, describeRegisteredEventTrigger as S, eventWatchUnavailable as T, runDispatchOutcome as U, readAutomationResult as V, WORKSPACE_SNAPSHOT_FAILED_EVENT as _, EVENT_WAIT_MS as a, workspaceSnapshotWatch as b, isEventMailboxMetadata as c, getEventCatalog as d, SLACK_EVENT_NAMESPACE as f, slackChannelMessageRunsAutomation as g, slackChannelMessageReplyThreadTs as h, skipInputBeforeConversationStop as i, requireValidEventTrigger as j, registeredResourceTypeSchema as k, renderEventBatchText as l, slackChannelMessageEvent as m, markConversationsStopped as n, enqueueEventNotification as o, requireSlackChannelMessageScope as p, session_stop_exports as r, eventBatchMessageEvents as s, getConversationStoppedAtMs as t, timerWatchCredentialSubject as u, WORKSPACE_SNAPSHOT_READY_EVENT as v, eventNamespaceSchema as w, automationEventCatalog as x, workspaceSnapshotFinishedEvent as y, deliversFinalText as z };
+export { automationResultSchema as A, maybePostAutomatedTurnLimitNotice as C, recordFinishedTurnForAutomatedLimit as D, renderSlackObjectCard as E, remindMissingAutomationResult as F, runDispatchOutcome as I, finishedRunReply as M, postsRunNotices as N, resetAutomatedTurnLimit as O, readAutomationResult as P, renderTaskInput as S, sendSlackReply as T, WORKSPACE_SNAPSHOT_FAILED_EVENT as _, EVENT_WAIT_MS as a, workspaceSnapshotWatch as b, isEventMailboxMetadata as c, getEventCatalog as d, SLACK_EVENT_NAMESPACE as f, slackChannelMessageRunsAutomation as g, slackChannelMessageReplyThreadTs as h, skipInputBeforeConversationStop as i, deliversFinalText as j, FINISH_AUTOMATION_RUN_TOOL_NAME as k, renderEventBatchText as l, slackChannelMessageEvent as m, markConversationsStopped as n, enqueueEventNotification as o, requireSlackChannelMessageScope as p, session_stop_exports as r, eventBatchMessageEvents as s, getConversationStoppedAtMs as t, timerWatchCredentialSubject as u, WORKSPACE_SNAPSHOT_READY_EVENT as v, resolveSlackReplyTarget as w, joinMailboxText as x, workspaceSnapshotFinishedEvent as y };