@sentry/junior 0.267.0 → 0.268.0

package/dist/{service-account-Do30HUNv.js → service-account-CKV2WTY7.js}

@@ -1,6 +1,6 @@
-import { B as isRecord, b as setSpanAttributes, h as logWarn } from "./logging-DuZ1A4ab.js";
-import { c as fetchWithBoundedOAuthErrorBodies, i as resolvePluginHeaderEnvRefs } from "./registry-FQutO926.js";
-import { a as MUTATION_LOCK_TTL_MS, c as withLock, i as getStateAdapter, s as fenceLock } from "./adapter-BybMEezj.js";
+import { B as isRecord, b as setSpanAttributes, h as logWarn } from "./logging-DLSpkSSr.js";
+import { c as fetchWithBoundedOAuthErrorBodies, i as resolvePluginHeaderEnvRefs } from "./registry-BgecKva0.js";
+import { a as MUTATION_LOCK_TTL_MS, c as withLock, i as getStateAdapter, s as fenceLock } from "./adapter-04AcD2SO.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { randomUUID } from "node:crypto";
 import { UnauthorizedError, auth } from "@modelcontextprotocol/sdk/client/auth.js";

package/dist/{service-account-BQasl-qq.js → service-account-DGjnDw9y.js}

@@ -1,6 +1,6 @@
-import { n as pluginCatalogRuntime } from "./catalog-runtime-cMlAI5LY.js";
-import { t as disconnectStateAdapter } from "./adapter-BybMEezj.js";
-import { n as finishServiceAccountSignIn, o as serviceAccountPlugins, r as getServiceAccountStatus, s as startServiceAccountSignIn, t as disconnectServiceAccount } from "./service-account-Do30HUNv.js";
+import { n as pluginCatalogRuntime } from "./catalog-runtime-BD9GSpc6.js";
+import { t as disconnectStateAdapter } from "./adapter-04AcD2SO.js";
+import { n as finishServiceAccountSignIn, o as serviceAccountPlugins, r as getServiceAccountStatus, s as startServiceAccountSignIn, t as disconnectServiceAccount } from "./service-account-CKV2WTY7.js";
 import { CLI_USAGE } from "./cli/run.js";
 import { createServer } from "node:http";
 // src/cli/service-account.ts

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

@@ -1,19 +1,19 @@
 import { t as __exportAll } from "./rolldown-runtime-nwUcYXjP.js";
-import { A as CORE_EVENT_NAMESPACE, Gn as normalizeToolNameFromResult, N as eventCatalogEntry, P as eventGuidance, Un as isToolResultError, Vn as isAssistantMessage, Wn as isToolResultMessage } from "./tasks-0ilmuCux.js";
-import { n as botConfig } from "./config-CdB6yJj5.js";
-import { h as logWarn, m as logInfo, p as logException } from "./logging-DuZ1A4ab.js";
-import { f as getConversationStore, m as getSqlExecutor } from "./viewer-DrN3oC2X.js";
-import { s as juniorConversations } from "./agent-invocations-CxKldAeB.js";
-import "./executor-VYrx_K4w.js";
-import { h as credentialSubjectSchema } from "./registry-FQutO926.js";
-import { $ as postSlackMessage, Zt as verifyTimerWatchCredentialSubject, dn as JUNIOR_THREAD_STATE_TTL_MS, gn as ToolInputError, p as getPlugins } from "./credentialed-CIGwoLU2.js";
-import { i as getStateAdapter } from "./adapter-BybMEezj.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 { r as sanitizeAssistantText } from "./assistant-reply-CT7VcXQe.js";
-import { r as appendAndEnqueueInboundMessage } from "./store-DvNZIsCr.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 { eventMatchFieldsSchema, 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
@@ -913,4 +1389,4 @@ async function skipInputBeforeConversationStop(context) {
 	await context.attempt.ack();
 	return { status: "completed" };
 }
-export { readAutomationResult as A, maybePostAutomatedTurnLimitNotice as C, automationResultSchema as D, FINISH_AUTOMATION_RUN_TOOL_NAME as E, runDispatchOutcome as M, deliversFinalText as O, renderTaskInput as S, resetAutomatedTurnLimit 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, remindMissingAutomationResult as j, finishedRunReply 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, recordFinishedTurnForAutomatedLimit as w, joinMailboxText as x, workspaceSnapshotFinishedEvent as y };
+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 };

package/dist/{skills-CQHrwfOa.js → skills-CfAnfImD.js}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-nwUcYXjP.js";
-import { h as logWarn } from "./logging-DuZ1A4ab.js";
+import { h as logWarn } from "./logging-DLSpkSSr.js";
 import { s as skillRoots } from "./package-discovery-DJBompdd.js";
-import { n as pluginCatalogRuntime } from "./catalog-runtime-cMlAI5LY.js";
+import { n as pluginCatalogRuntime } from "./catalog-runtime-BD9GSpc6.js";
 import path from "node:path";
 import { z } from "zod";
 import fs from "node:fs/promises";

package/dist/{spawn-BHuqN14f.js → spawn-cmq9p4Ly.js}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-nwUcYXjP.js";
-import { dt as actorFromRun, ft as toolInvocationDestination } from "./agent-runner-DgNATN4D.js";
-import { n as createAndEnqueueAgentInvocation } from "./work-DUQoNcqP.js";
+import { Bt as actorFromRun, Vt as toolInvocationDestination } from "./agent-runner-CAYfFmU7.js";
+import { n as createAndEnqueueAgentInvocation } from "./work-3N-GHY9m.js";
 // src/chat/agent-invocations/spawn.ts
 var spawn_exports = /* @__PURE__ */ __exportAll({ bindSpawnAgent: () => bindSpawnAgent });
 /** Bind a Run's Actor and credentials to new Agent invocations. */

package/dist/{store-6EetVP-m.js → store-C5PN02QO.js}

@@ -1,8 +1,8 @@
 import { l as TURN_REASONING_LEVELS, s as modelProfileSchema } from "./model-profile-Bg8EoCKD.js";
-import { f as getConversationStore, m as getSqlExecutor } from "./viewer-DrN3oC2X.js";
-import { a as juniorAgentInvocations, i as juniorAgentBindings, n as AGENT_INVOCATION_PARENT_MAILBOX_STATUSES, t as AGENT_INVOCATION_MAILBOX_STATUSES } from "./agent-invocations-CxKldAeB.js";
-import "./executor-VYrx_K4w.js";
-import { p as credentialContextSchema } from "./registry-FQutO926.js";
+import { h as getSqlExecutor, p as getConversationStore } from "./viewer-CpXTGlep.js";
+import { a as juniorAgentInvocations, i as juniorAgentBindings, n as AGENT_INVOCATION_PARENT_MAILBOX_STATUSES, t as AGENT_INVOCATION_MAILBOX_STATUSES } from "./agent-invocations-C1RNOCs8.js";
+import "./executor-4vhvsMZJ.js";
+import { p as credentialContextSchema } from "./registry-BgecKva0.js";
 import { z } from "zod";
 import { createHash } from "node:crypto";
 import { and, asc, count, countDistinct, desc, eq, inArray, lt, ne, or, sql } from "drizzle-orm";

package/dist/{store-B8CABbmR.d.ts → store-xMuuXRE0.d.ts}

@@ -48,6 +48,11 @@ type Usage = z.output<typeof usageSchema>;
 type AgentTurnUsage = Usage;
 type ConversationSource = "api" | "internal" | "local" | "plugin" | "event" | "scheduler" | "slack" | "web";
 type ConversationStatus = "paused" | "failed" | "idle" | "pending" | "running";
+/** Cumulative duration and usage that one Run reported. */
+interface ConversationRunMetrics {
+  durationMs: number;
+  usage?: AgentTurnUsage;
+}
 interface ConversationExecution {
   lastCheckpointAtMs?: number;
   lastEnqueuedAtMs?: number;
@@ -73,10 +78,9 @@ interface Conversation {
   createdAtMs: number;
   destination?: Destination;
   execution: ConversationExecution;
-  executionMetrics?: {
-    durationMs: number;
+  /** Metrics of the latest Run that wrote metrics. */
+  executionMetrics?: ConversationRunMetrics & {
     runId?: string;
-    usage?: AgentTurnUsage;
   };
   lastActivityAtMs: number;
   /** Immutable parent Conversation. */
@@ -115,6 +119,11 @@ interface ConversationStore {
   get(args: {
     conversationId: string;
   }): Promise<Conversation | undefined>;
+  /** Read one Run's stored metrics, including a Run that is not the latest. */
+  getRunMetrics(args: {
+    conversationId: string;
+    runId: string;
+  }): Promise<ConversationRunMetrics | undefined>;
   /** Resolve the durable conversation bound to one provider conversation. */
   getConversationIdByProviderConversation(args: {
     provider: string;
@@ -180,10 +189,7 @@ interface ConversationStore {
     destination?: Destination;
     execution: ConversationExecution;
     lastActivityAtMs: number;
-    metrics: {
-      durationMs: number;
-      usage?: AgentTurnUsage;
-    } | null;
+    metrics: ConversationRunMetrics | null;
     actor?: StoredSlackActor;
     source?: ConversationSource;
     title?: string;

package/dist/{store-DvNZIsCr.js → store-zPEoJPBB.js}

@@ -1,6 +1,6 @@
-import { $t as appendExclusiveInboundMessage, Cn as requestConversationWork$1, En as stopConversationWork$1, Qt as ackMessages$1, Sn as requestAnotherSlice$1, Tn as steerWebPendingMessages$1, _n as markConversationWorkEnqueued$1, an as clearExpiredConversationLease$1, bn as releaseConversationWork$1, cn as deadLetterAttempt$1, dn as getConversationWorkState$1, en as appendInboundMessage, gn as listActiveConversationIds$1, in as clearConsumedConversationWake$1, ln as drainConversationMailbox$1, nn as cancelHumanFacingPendingMessages$1, on as completeConversationStop$1, rn as checkInConversationWork$1, sn as completeConversationWork$1, tn as beginConversationResume$1, un as getConversation$1, vn as recordAttemptFailure$1, wn as startConversationWork$1, xn as removeActiveConversation$1, yn as recordConversationRetry$1 } from "./tasks-0ilmuCux.js";
-import { f as getConversationStore } from "./viewer-DrN3oC2X.js";
-import "./job-queue-C0BZSa7r.js";
+import { Cn as removeActiveConversation$1, Dn as steerWebPendingMessages$1, En as startConversationWork$1, On as stopConversationWork$1, Sn as releaseConversationWork$1, Tn as requestConversationWork$1, an as checkInConversationWork$1, bn as recordAttemptFailure$1, cn as completeConversationStop$1, dn as drainConversationMailbox$1, en as ackMessages$1, fn as getConversation$1, in as cancelHumanFacingPendingMessages$1, ln as completeConversationWork$1, nn as appendInboundMessage, on as clearConsumedConversationWake$1, pn as getConversationWorkState$1, rn as beginConversationResume$1, sn as clearExpiredConversationLease$1, tn as appendExclusiveInboundMessage, un as deadLetterAttempt$1, vn as listActiveConversationIds$1, wn as requestAnotherSlice$1, xn as recordConversationRetry$1, yn as markConversationWorkEnqueued$1 } from "./tasks-SB9z-VTU.js";
+import { p as getConversationStore } from "./viewer-CpXTGlep.js";
+import "./job-queue-In9QKz-I.js";
 // src/chat/task-execution/store.ts
 function metadataStore(options) {
 	return options.conversationStore ?? getConversationStore();