@sentry/junior 0.239.0 → 0.241.0

package/dist/{agent-runner--1wC26S6.js → agent-runner-CMZ6lFQe.js}

@@ -1,28 +1,29 @@
-import { b as getGatewayApiKey, c as hasCompactedConversationContext, d as unwrapCurrentInstruction, f as escapeXml, g as getProviderErrorAttributes, h as findProviderError, i as completeText, l as isCompactionSummaryText, m as createProviderError, n as GEN_AI_SERVER_ADDRESS, o as resolveGatewayModel, p as ProviderError, r as completeObject, s as COMPACTION_SUMMARY_PREFIX, t as GEN_AI_PROVIDER_NAME, u as renderCurrentInstruction, v as isProviderRetryError, x as resolveGatewayCredential, y as MISSING_GATEWAY_CREDENTIALS_ERROR } from "./client-DNf-sJmM.js";
-import { C as withLogContext, F as normalizeIdentityEmail, I as isRecord$3, L as toOptionalNumber, R as toOptionalString, a as extractGenAiUsageSummary, b as setTags, c as getLogContextAttributesForSpan, d as logException, f as logInfo, g as serializeGenAiAttribute, i as extractGenAiUsageAttributes, l as getTracePropagationHeaders, m as normalizeGenAiFinishReason, p as logWarn, s as getLogContextAttributes, u as logError, v as setSpanAttributes, w as withSpan, x as summarizeMessageText, y as setSpanStatus } from "./logging-Crg0e1jb.js";
-import { m as startInactiveSpan, n as captureMessage, v as withActiveSpan } from "./sentry-CgWZM_kV.js";
-import { a as toCanonicalInputMessage, c as toGenAiPayloadMetadata, i as runWithConversationPrivacy, l as toGenAiPayloadTraceAttributes, o as toCanonicalOutputMessage, r as resolveConversationPrivacy, s as toGenAiMessagesTraceAttributes, t as canExposeConversationPayload } from "./conversation-privacy-CrYizZM3.js";
-import { i as getChatConfig, n as botConfig, o as getSlackBotToken, v as normalizeSlackEmojiName } from "./config-B8QN-04U.js";
+import { b as getGatewayApiKey, c as hasCompactedConversationContext, d as unwrapCurrentInstruction, f as escapeXml, g as getProviderErrorAttributes, h as findProviderError, i as completeText, l as isCompactionSummaryText, m as createProviderError, n as GEN_AI_SERVER_ADDRESS, o as resolveGatewayModel, p as ProviderError, r as completeObject, s as COMPACTION_SUMMARY_PREFIX, t as GEN_AI_PROVIDER_NAME, u as renderCurrentInstruction, v as isProviderRetryError, x as resolveGatewayCredential, y as MISSING_GATEWAY_CREDENTIALS_ERROR } from "./client-CRZ-i1tH.js";
+import { C as withLogContext, F as normalizeIdentityEmail, I as isRecord$3, L as toOptionalNumber, R as toOptionalString, a as extractGenAiUsageSummary, b as setTags, c as getLogContextAttributesForSpan, d as logException, f as logInfo, g as serializeGenAiAttribute, i as extractGenAiUsageAttributes, l as getTracePropagationHeaders, m as normalizeGenAiFinishReason, p as logWarn, u as logError, v as setSpanAttributes, w as withSpan, x as summarizeMessageText, y as setSpanStatus } from "./logging-LQnLlPf8.js";
+import { m as startInactiveSpan, v as withActiveSpan } from "./sentry-CgWZM_kV.js";
+import { a as toCanonicalInputMessage, c as toGenAiPayloadMetadata, i as runWithConversationPrivacy, l as toGenAiPayloadTraceAttributes, o as toCanonicalOutputMessage, r as resolveConversationPrivacy, s as toGenAiMessagesTraceAttributes, t as canExposeConversationPayload } from "./conversation-privacy-D5Byl5eC.js";
+import { i as getChatConfig, n as botConfig, v as normalizeSlackEmojiName } from "./config-CCI82OTD.js";
 import { a as formatModelProfiles, c as profileConfig, i as formatModelProfile, l as TURN_REASONING_LEVELS, n as ModelProfileNotConfiguredError, o as modelIdForProfile, s as modelProfileSchema } from "./model-profile-BwU8mqwD.js";
 import { a as isUserActor, d as parseSlackTeamId, f as parseSlackUserId, g as parseSlackMessageTs, l as parseSlackChannelId, s as parseStoredSlackActor, u as parseSlackChannelReferenceId } from "./actor-BTtLaeWy.js";
-import { D as readUserTimezone, M as parseDestination, O as saveUserTimezone, P as sameDestination$1, b as addAgentTurnUsage, c as getConversationEventStore, d as getDb, f as getSqlExecutor, l as getConversationMessageSearchStore, r as readActorIdentity, u as getConversationStore, w as hasAgentTurnUsage } from "./viewer-EftpWXcF.js";
+import { F as sameDestination$1, N as parseDestination, T as hasAgentTurnUsage, c as getConversationEventStore, d as getDb, f as getSqlExecutor, l as getConversationMessageSearchStore, r as readActorIdentity, u as getConversationStore, x as addAgentTurnUsage } from "./viewer-D6stAU7h.js";
 import { n as juniorDestinations } from "./destinations-BeBiJeEM.js";
-import { A as juniorArtifacts, D as juniorConversations, O as juniorIdentities, S as juniorConversationAnnotations, T as juniorAttachments, _ as juniorConversationBriefs, a as juniorSchedulerRuns, f as AGENT_INVOCATION_MAILBOX_STATUSES, l as juniorStats, o as juniorSchedulerTasks, s as juniorAutomationVersions, u as juniorEventAutomations } from "./executor-BQV1Zc1z.js";
+import { A as juniorArtifacts, D as juniorConversations, O as juniorIdentities, S as juniorConversationAnnotations, T as juniorAttachments, _ as juniorConversationBriefs, a as juniorSchedulerRuns, f as AGENT_INVOCATION_MAILBOX_STATUSES, l as juniorStats } from "./executor-CewKi7EG.js";
 import { d as instructionActors, f as instructionProvenanceFor, p as sameActorIdentity, t as KNOWN_CONVERSATION_EVENT_TYPES, u as contextProvenance } from "./history-BLTUgFYO.js";
 import { a as listReferenceFiles, c as soulPathCandidates, l as worldPathCandidates } from "./package-discovery-BVvSnQBB.js";
-import { a as resolveAuthTokenPlaceholder, c as fetchWithBoundedOAuthErrorBodies, d as credentialContextForActor, f as credentialContextSchema, h as CredentialUnavailableError, i as resolvePluginHeaderEnvRefs, l as getOAuthProviderErrorAttributes, m as credentialUserSubjectId, o as resolvePluginCommandEnv, p as credentialSubjectSchema, s as OAuthProviderError } from "./registry-BJME30oR.js";
-import { n as pluginCatalogRuntime } from "./catalog-runtime-DpB_hG_I.js";
-import { a as parseSkillInvocation, i as parseSkillFile, n as findSkillByName, r as loadSkillsByName, t as discoverSkills } from "./skills-CMl248J3.js";
-import { C as isToolResultError, D as stripRuntimeTurnContext, E as retainRuntimeTurnContext, H as recordAuthorizationRequested, I as loadTurnRoute, K as recordToolExecutionStarted, L as openConversationProjection, M as loadConnectedMcpProviders, N as loadConversationProjection, O as trimTrailingAssistantMessages, R as recordAgentsInstructionsUpdated, S as isContinuablePiBoundary, T as normalizeToolNameFromResult, U as recordGuardianActionReviewed, W as recordMcpProviderConnected, _ as getTerminalAssistantMessages, _t as historyItemFromPiMessage, d as TurnSliceLimitExceededError, f as assertTurnToolCallLimit, g as getPiMessageRole, gt as getAgentContextInputLimitTokens, h as extractAssistantText, ht as getAgentContextCompactionTriggerTokens, k as TURN_CONTEXT_TAG, m as isTurnExecutionLimitExceededError, mt as estimateTextTokens, n as loadTurnCheckpoint, nt as resolveTaskTitle, q as recordTurnRoute, r as saveTurnCheckpoint, t as continuableMessages, tt as fallbackShortTitle, v as getUserMessageInstructionText, vt as piMessageFromHistoryItem, w as isToolResultMessage, x as isAssistantMessage, y as hasRuntimeTurnContext, z as recordAttachmentsDelivered } from "./checkpoint-CN7yMfSo.js";
-import { A as getWorkspaceSnapshotBuilder, B as cancelWatch, Bt as saveObjectAnnotations, C as WorkspaceValidationError, D as setWorkspaceSnapshotBuild, E as setWorkspaceSnapshot, F as RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS, G as findMatchingWatches, H as createTimerWatch, I as RESOURCE_SUBSCRIPTION_MAX_TTL_MS, It as matchSlackAttachments, K as listWatches, L as RESOURCE_WATCH_TOOL_SOURCE, M as workspaceRepoCheckoutPath, N as resolveChannelCapabilities, O as SANDBOX_RUNTIME, P as getSlackToolContext, R as STOP_WATCHING_TOOL_NAME, S as updateWorkspace, T as loadSnapshotsForProfile, U as createWatch, Vt as createPluginAnnotations, W as deliverWatch, _ as deleteWorkspace, at as getSlackClient, b as listWorkspaces, c as getPluginTools, ct as normalizeSlackConversationId, et as verifyTimerWatchCredentialSubject, g as createWorkspace, gt as getDashboardTaskLink, j as tryWorkspaceRepoCheckoutPath, k as deleteWorkspaceSnapshotBuilders, l as getPluginUserPromptContributions, mt as getDashboardConversationLink, n as applyPluginFormatMarkdown, nt as downloadPrivateSlackFile, ot as isConversationScopedChannel, pt as JUNIOR_THREAD_STATE_TTL_MS, r as createPluginHookRunner, rt as getFilePermalink, s as getPluginSystemPromptContributions, st as isDmChannel$1, tt as SlackActionError, u as getPlugins, ut as withSlackRetries, v as getWorkspace, w as invalidateReadySnapshot, xt as createPluginLogger, y as getWorkspaceByName, z as cancelSubscriptions } from "./agent-hooks-DzfA5m3R.js";
+import { a as resolveAuthTokenPlaceholder, c as fetchWithBoundedOAuthErrorBodies, d as credentialContextForActor, f as credentialContextSchema, h as CredentialUnavailableError, i as resolvePluginHeaderEnvRefs, l as getOAuthProviderErrorAttributes, m as credentialUserSubjectId, o as resolvePluginCommandEnv, p as credentialSubjectSchema, s as OAuthProviderError } from "./registry-DPDH6s5G.js";
+import { n as pluginCatalogRuntime } from "./catalog-runtime-Tz0O2MZe.js";
+import { a as parseSkillInvocation, i as parseSkillFile, n as findSkillByName, r as loadSkillsByName, t as discoverSkills } from "./skills-BtHhSATy.js";
+import { A as formatSlackLink, Ct as loadConversationProjection, D as automationRevision, Dt as openConversationProjection, Et as loadTurnRoute, F as addReactionToMessage, G as loadTurnCheckpoint, Gt as fallbackShortTitle, I as getSlackMessagePermalink, It as recordToolExecutionStarted, K as saveTurnCheckpoint, Kt as resolveTaskTitle, L as openSlackDirectMessage, Lt as recordTurnRoute, Mt as recordAuthorizationRequested, N as slackMention, Nt as recordGuardianActionReviewed, Ot as recordAgentsInstructionsUpdated, Pt as recordMcpProviderConnected, R as postSlackEphemeralMessage, St as loadConnectedMcpProviders, V as uploadFilesToConversation, W as continuableMessages, _t as trimTrailingAssistantMessages, a as readScheduledAutomation, an as getAgentContextCompactionTriggerTokens, at as getPiMessageRole, b as saveEventAutomation, cn as piMessageFromHistoryItem, ct as hasRuntimeTurnContext, dt as isContinuablePiBoundary, et as TurnSliceLimitExceededError, f as createEventAutomation, ft as isToolResultError, g as getEventAutomation, gt as stripRuntimeTurnContext, ht as retainRuntimeTurnContext, in as estimateTextTokens, it as extractAssistantText, k as escapeSlackMrkdwnText, kt as recordAttachmentsDelivered, mt as normalizeToolNameFromResult, o as saveScheduledAutomation, on as getAgentContextInputLimitTokens, ot as getTerminalAssistantMessages, p as deleteEventAutomation, pt as isToolResultMessage, r as listScheduledAutomationsForTeam, rt as isTurnExecutionLimitExceededError, sn as historyItemFromPiMessage, st as getUserMessageInstructionText, t as createScheduledAutomation, tt as assertTurnToolCallLimit, ut as isAssistantMessage, v as listEventAutomationsForTeam, vt as TURN_CONTEXT_TAG, x as setEventAutomationStatus, yt as ToolInputError, z as postSlackMessage } from "./tasks-CO52vLkI.js";
+import { A as getWorkspaceSnapshotBuilder, B as cancelWatch, Bt as isConversationScopedChannel, C as WorkspaceValidationError, D as setWorkspaceSnapshotBuild, E as setWorkspaceSnapshot, F as RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS, Ft as SlackActionError, G as findMatchingWatches, H as createTimerWatch, Ht as normalizeSlackConversationId, I as RESOURCE_SUBSCRIPTION_MAX_TTL_MS, It as downloadPrivateSlackFile, K as listWatches, L as RESOURCE_WATCH_TOOL_SOURCE, Lt as getFilePermalink, M as workspaceRepoCheckoutPath, Mt as defaultTimezone, N as resolveChannelCapabilities, Nt as resolveUserTimezone, O as SANDBOX_RUNTIME, Ot as saveObjectAnnotations, P as getSlackToolContext, R as STOP_WATCHING_TOOL_NAME, S as updateWorkspace, T as loadSnapshotsForProfile, U as createWatch, Vt as isDmChannel$1, W as deliverWatch, Wt as withSlackRetries, _ as deleteWorkspace, b as listWorkspaces, c as getPluginTools, et as verifyTimerWatchCredentialSubject, g as createWorkspace, it as getDashboardTaskLink, j as tryWorkspaceRepoCheckoutPath, k as deleteWorkspaceSnapshotBuilders, kt as createPluginAnnotations, l as getPluginUserPromptContributions, lt as createPluginLogger, nt as getDashboardConversationLink, r as createPluginHookRunner, s as getPluginSystemPromptContributions, tt as JUNIOR_THREAD_STATE_TTL_MS, u as getPlugins, v as getWorkspace, w as invalidateReadySnapshot, wt as matchSlackAttachments, y as getWorkspaceByName, z as cancelSubscriptions, zt as getSlackClient } from "./agent-hooks-C5zYOaJk.js";
 import { F as isVisionImageMediaType, G as removedCardSchema, L as briefLinkSchema, R as briefOutcomeStatusSchema, z as conversationBriefSchema } from "./conversation-DwD-vquD.js";
-import { A as SANDBOX_DATA_ROOT, C as getDefaultRedisStateAdapterFor, D as fenceLock, E as acquireActiveLock, F as sandboxSkillFile, I as sandboxSkillPathResolution, M as SANDBOX_SKILLS_ROOT, N as SANDBOX_WORKSPACE_ROOT, O as withLock, P as sandboxSkillDir, _ as workspaceSnapshotNotReadyUserMessage, a as isAbortError, b as buildNonInteractiveShellScript, c as isSandboxCommandStreamInterruptedError, d as isSnapshottingError, f as throwSandboxOperationError, g as isWorkspaceSnapshotNotReadyError, h as getWorkspaceSnapshotNotReadyError, i as ensureDockerDaemon, j as SANDBOX_REPOS_ROOT, k as sleep$2, l as isSandboxMissingError, m as WorkspaceSnapshotNotReadyError, n as hash, o as isAlreadyExistsError, p as wrapSandboxSetupError, r as isStale, s as isSandboxApiTransientError, t as create, u as isSandboxUnavailableError, v as getVercelSandboxCredentials, w as getStateAdapter, x as runNonInteractiveCommand, y as buildCommandScript } from "./profile-XzHSfIah.js";
-import { n as canReusePendingAuthLink, t as abandonReplacedPendingAuth } from "./pending-auth-DauOaies.js";
-import { a as NO_REPLY_MARKER, c as CooperativeTurnYieldError, i as sanitizeAssistantText, l as TurnInputCommitLostError, n as decideReply, o as isNoReplyMarker, p as isTurnInputCommitLostError, r as getAssistantReplyText, t as authorizationId } from "./oauth-authorization-Bdu39G-H.js";
+import { A as SANDBOX_DATA_ROOT, C as getDefaultRedisStateAdapterFor, D as fenceLock, E as acquireActiveLock, F as sandboxSkillFile, I as sandboxSkillPathResolution, M as SANDBOX_SKILLS_ROOT, N as SANDBOX_WORKSPACE_ROOT, O as withLock, P as sandboxSkillDir, _ as workspaceSnapshotNotReadyUserMessage, a as isAbortError, b as buildNonInteractiveShellScript, c as isSandboxCommandStreamInterruptedError, d as isSnapshottingError, f as throwSandboxOperationError, g as isWorkspaceSnapshotNotReadyError, h as getWorkspaceSnapshotNotReadyError, i as ensureDockerDaemon, j as SANDBOX_REPOS_ROOT, k as sleep$2, l as isSandboxMissingError, m as WorkspaceSnapshotNotReadyError, n as hash, o as isAlreadyExistsError, p as wrapSandboxSetupError, r as isStale, s as isSandboxApiTransientError, t as create, u as isSandboxUnavailableError, v as getVercelSandboxCredentials, w as getStateAdapter, x as runNonInteractiveCommand, y as buildCommandScript } from "./profile-mWuVZ8ht.js";
+import { n as canReusePendingAuthLink, t as abandonReplacedPendingAuth } from "./pending-auth-CT3ojhKe.js";
+import { a as NO_REPLY_MARKER, c as CooperativeTurnYieldError, i as sanitizeAssistantText, l as TurnInputCommitLostError, n as decideReply, o as isNoReplyMarker, p as isTurnInputCommitLostError, r as getAssistantReplyText, t as authorizationId } from "./oauth-authorization-Clzkm-Ts.js";
+import { i as isValidTimeZone, r as getZonedDateTimeParts } from "./cadence-D00SCzT1.js";
 import { r as EVENT_AUTHOR_ID } from "./prompt-CMU-B4FA.js";
-import { a as createSandboxSession, c as postinstall, d as getSandboxResources, i as bindSandboxFileSystem, l as setSnapshotSpanAttributes, n as isMissingError, o as stopSession, r as resolve$1, s as dependencies } from "./resolve-ZKXfsZuZ.js";
-import { a as getVercelConversationWorkQueue, f as getTurnRequestDeadline, n as sendNextWorkspaceSnapshotJob, r as sendWorkspaceSnapshotJob } from "./job-queue-D82gksYM.js";
-import { A as eventAutomationSchema, D as scheduledRunSchema, E as scheduledAutomationSchema, M as compileScheduleIntent, N as isValidTimeZone$1, O as automationInstructionToolSchema, P as scheduleIntentSchema, R as getZonedDateTimeParts, S as automationVersionSchema, T as SCHEDULED_AUTOMATION_SYSTEM_ACTOR, j as ScheduleIntentError, k as automationTitleSchema, z as taskOutcomeInputSchema } from "./automation-CrQGQ2MT.js";
+import { a as createSandboxSession, c as postinstall, d as getSandboxResources, i as bindSandboxFileSystem, l as setSnapshotSpanAttributes, n as isMissingError, o as stopSession, r as resolve$1, s as dependencies } from "./resolve-BAN8BSGy.js";
+import { a as getVercelConversationWorkQueue, f as getTurnRequestDeadline, n as sendNextWorkspaceSnapshotJob, r as sendWorkspaceSnapshotJob } from "./job-queue-C6o2aJQ6.js";
+import { F as taskOutcomeInputSchema, M as compileScheduleIntent, N as scheduleIntentSchema, O as automationInstructionToolSchema, T as SCHEDULED_AUTOMATION_SYSTEM_ACTOR, j as ScheduleIntentError, k as automationTitleSchema } from "./automation-gznOMaQ2.js";
 import { r as isExperimentalFeatureEnabled } from "./experimental-Qn9rKLgx.js";
 import { n as privateTraceResultAttributes } from "./private-trace-result-BLvBjy_e.js";
 import { streamSimple } from "@earendil-works/pi-ai/compat";
@@ -33,8 +34,8 @@ import { isDeepStrictEqual } from "node:util";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { z } from "zod";
 import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
-import { and, asc, desc, eq, gt, gte, inArray, isNotNull, isNull, lt, lte, ne, notExists, notInArray, or, sql } from "drizzle-orm";
-import { EgressAuthRequired, EgressPolicyDenied, PluginToolInputError, actorSchema, destinationSchema, eventMatchSchema, eventMatches, eventSchema, missingToolAnnotationKeys, normalizeEventIdentifier, objectTypeSchema, ownedObjectAnnotationSchema, pluginAuthorizationSchema, pluginCredentialHeaderTransformSchema, pluginCredentialResultSchema, pluginGrantSchema, pluginProviderAccountSchema, pluginStoredTokensSchema, slackDestinationSchema, sourceSchema, stableEventMatchKey, taskOutcomeSchema, watchResultSchema } from "@sentry/junior-plugin-api";
+import { and, asc, desc, eq, gt, gte, inArray, isNotNull, isNull, lt, lte, ne, notExists, or, sql } from "drizzle-orm";
+import { EgressAuthRequired, EgressPolicyDenied, PluginToolInputError, actorSchema, destinationSchema, eventMatchSchema, eventSchema, missingToolAnnotationKeys, normalizeEventIdentifier, objectTypeSchema, ownedObjectAnnotationSchema, pluginAuthorizationSchema, pluginCredentialHeaderTransformSchema, pluginCredentialResultSchema, pluginGrantSchema, pluginProviderAccountSchema, pluginStoredTokensSchema, sourceSchema, stableEventMatchKey, watchResultSchema } from "@sentry/junior-plugin-api";
 import { alias } from "drizzle-orm/pg-core";
 import { Agent, estimateContextTokens } from "@earendil-works/pi-agent-core";
 import fs from "node:fs/promises";
@@ -221,15 +222,6 @@ var SkillSandbox = class {
 	}
 };
 //#endregion
-//#region src/chat/tools/execution/tool-input-error.ts
-/** Thrown when a tool fails due to invalid model/user input, not a system error. */
-var ToolInputError = class extends Error {
-	constructor(message, options) {
-		super(message, options);
-		this.name = "ToolInputError";
-	}
-};
-//#endregion
 //#region src/chat/tools/sandbox/file-utils.ts
 const MAX_TEXT_CHARS = 6e4;
 const RIPGREP_EXCLUDED_GLOBS = ["!**/.git/**", "!**/node_modules/**"];
@@ -266,7 +258,8 @@ function isMissingPathError(error) {
 }
 /** Reject an expected missing search/list path through the tool-error channel. */
 function missingPathSearchResult(params) {
-	throw new ToolInputError(`Path not found: ${params.displayPath ?? params.missingPath ?? params.path}`);
+	const textPath = params.displayPath ?? params.missingPath ?? params.path;
+	throw new ToolInputError(`Path not found: ${textPath}`);
 }
 function escapeRegExp(value) {
 	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -810,10 +803,102 @@ function shouldEmitDevAgentTrace() {
 	return process.env.NODE_ENV === "development";
 }
 //#endregion
+//#region src/chat/automation-result.ts
+/**
+* Automation run result.
+*
+* A Scheduled automation or Event automation run ends with one declared
+* result. The run does not deliver its final assistant text. The work owner
+* reads the declared result and applies the stored outcomes.
+*/
+/** Model-facing tool that ends an Automation run. */
+const FINISH_AUTOMATION_RUN_TOOL_NAME = "finishAutomationRun";
+/** One declared result for an Automation run. */
+const automationResultSchema = z.discriminatedUnion("result", [
+	z.object({
+		result: z.literal("send_message"),
+		message: z.string().transform(sanitizeAssistantText).pipe(z.string().min(1))
+	}),
+	z.object({
+		result: z.literal("no_action"),
+		reason: z.string().trim().min(1)
+	}),
+	z.object({
+		result: z.literal("misconfigured"),
+		reason: z.string().trim().min(1)
+	})
+]);
+/**
+* Return whether the runtime delivers the final assistant text of a run. It
+* does not for a dispatch with no outcomes. It does not for an Automation
+* run, which posts only its declared message, after the run.
+*/
+function deliversFinalText(dispatch) {
+	return dispatch?.outcomes?.length !== 0 && !dispatch?.declaresResult;
+}
+/**
+* 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
+* reply to its outcomes. The failed execution shows on the Automation.
+*/
+function finishedRunReply(result, dispatch) {
+	if (!dispatch?.declaresResult) return result.diagnostics.outcome === "success" ? void 0 : result.text;
+	return result.diagnostics.outcome === "success" && result.automation?.result === "send_message" && dispatch.outcomes?.length !== 0 ? result.text : void 0;
+}
+/**
+* Read the last successful declared result from agent history items.
+*
+* Pass the whole run history, not only the current slice. An Automation run
+* owns its dispatch Conversation, and a resumed slice must see a result that
+* an earlier slice already saved.
+*/
+function readAutomationResult(messages) {
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const message = messages[index];
+		if (!isToolResultMessage(message) || isToolResultError(message) || normalizeToolNameFromResult(message) !== "finishAutomationRun") continue;
+		const parsed = automationResultSchema.safeParse(message.details);
+		if (parsed.success) return parsed.data;
+	}
+}
+/**
+* Map one finished agent run to its dispatch outcome. A declared
+* `misconfigured` result becomes a blocked dispatch with the declared reason.
+*/
+function runDispatchOutcome(result) {
+	if (result.diagnostics.outcome !== "success") return {
+		errorMessage: result.diagnostics.errorMessage ?? `Agent turn ended with ${result.diagnostics.outcome}.`,
+		outcome: "failed"
+	};
+	if (result.automation?.result === "misconfigured") return {
+		errorMessage: result.automation.reason,
+		outcome: "blocked"
+	};
+	return { outcome: "completed" };
+}
+const MISSING_RESULT_REMINDER = "This automation run has not ended. Your text was not delivered. Call `finishAutomationRun` now with one result.";
+/**
+* Return agent history plus a reminder when the model stopped without a
+* declared result, or undefined when the run already declared one.
+*/
+function remindMissingAutomationResult(messages) {
+	const last = messages.at(-1);
+	if (!isAssistantMessage(last) || last.stopReason !== "stop" || readAutomationResult(messages)) return;
+	return [...messages, {
+		role: "user",
+		content: [{
+			type: "text",
+			text: MISSING_RESULT_REMINDER
+		}],
+		timestamp: Date.now()
+	}];
+}
+//#endregion
 //#region src/chat/services/turn-result.ts
 /** Process raw agent messages into a structured AgentRunResult. */
 function buildTurnResult(input) {
-	const { newMessages, toolCalls, sandboxRef, durationMs, shouldTrace, usage, executionProfile, modelId } = input;
+	if (input.requireAutomationResult) return buildAutomationTurnResult(input);
+	const { newMessages, sandboxRef, shouldTrace } = input;
 	const toolResults = newMessages.filter(isToolResultMessage);
 	const assistantMessages = newMessages.filter(isAssistantMessage);
 	const terminalAssistantMessages = getTerminalAssistantMessages(newMessages);
@@ -856,29 +941,68 @@ function buildTurnResult(input) {
 		"app.ai.assistant_messages": assistantMessages.length,
 		...stopReason ? { "gen_ai.response.finish_reasons": [stopReason] } : void 0
 	});
-	const resolvedDiagnostics = {
+	return {
+		text: primaryText,
+		sandboxRef,
+		piMessages: input.piMessages,
+		diagnostics: buildDiagnostics(input, {
+			outcome,
+			usedPrimaryText,
+			stopReason,
+			errorMessage,
+			lastAssistant
+		})
+	};
+}
+function buildDiagnostics(input, result) {
+	const { outcome, errorMessage, lastAssistant } = result;
+	const toolResults = input.newMessages.filter(isToolResultMessage);
+	return {
 		outcome,
-		modelId,
-		assistantMessageCount: assistantMessages.length,
-		reasoningLevel: executionProfile.reasoningLevel,
-		toolCalls,
+		modelId: input.modelId,
+		assistantMessageCount: input.newMessages.filter(isAssistantMessage).length,
+		reasoningLevel: input.executionProfile.reasoningLevel,
+		toolCalls: input.toolCalls,
 		toolResultCount: toolResults.length,
-		toolErrorCount,
-		usedPrimaryText,
-		durationMs,
-		usage,
-		stopReason,
+		toolErrorCount: toolResults.filter((toolResult) => toolResult.isError).length,
+		usedPrimaryText: result.usedPrimaryText,
+		durationMs: input.durationMs,
+		usage: input.usage,
+		stopReason: result.stopReason,
 		errorMessage,
 		providerError: outcome === "provider_error" && errorMessage ? createProviderError(errorMessage, {
-			modelId,
-			retryable: lastAssistant !== void 0 && isAssistantMessage(lastAssistant) && isRetryableAssistantError(lastAssistant)
+			modelId: input.modelId,
+			retryable: isAssistantMessage(lastAssistant) && isRetryableAssistantError(lastAssistant)
 		}) : void 0
 	};
+}
+/**
+* Build the result of an Automation run from its declared result. Final
+* assistant text is not used. A run without a declared result fails.
+*/
+function buildAutomationTurnResult(input) {
+	const lastAssistant = input.newMessages.filter(isAssistantMessage).at(-1);
+	const stopReason = lastAssistant?.stopReason;
+	const automation = readAutomationResult(input.piMessages ?? input.newMessages);
+	const outcome = automation ? "success" : stopReason === "error" ? "provider_error" : "execution_failure";
+	const errorMessage = outcome === "provider_error" ? lastAssistant?.errorMessage : outcome === "execution_failure" ? "Automation run ended without a declared result." : void 0;
+	if (input.shouldTrace) logInfo("agent.message.generated", {
+		"app.message.kind": "automation_result",
+		"app.ai.outcome": outcome,
+		"app.automation.result": automation?.result ?? "missing"
+	});
 	return {
-		text: primaryText,
-		sandboxRef,
+		text: automation?.result === "send_message" ? automation.message : "",
+		...automation ? { automation } : void 0,
+		sandboxRef: input.sandboxRef,
 		piMessages: input.piMessages,
-		diagnostics: resolvedDiagnostics
+		diagnostics: buildDiagnostics(input, {
+			outcome,
+			usedPrimaryText: automation?.result === "send_message",
+			stopReason,
+			errorMessage,
+			lastAssistant
+		})
 	};
 }
 //#endregion
@@ -1741,11 +1865,19 @@ const SLACK_ACTION_RULES = [
 	"- Ambient reaction requests target the current inbound message; do not ask for a message reference.",
 	`- When no visible thread reply is requested or useful, keep tool-calling messages text-free and make the final message exactly ${NO_REPLY_MARKER}.`
 ];
+const AUTOMATION_RUN_RULES = [
+	"- This run comes from a stored automation, not from a person. The stored instruction is the job, and its creator already approved it.",
+	"- Nobody reads this run while it executes. Do not ask questions, ask for approval, or offer options. Infer conservatively and do the work now.",
+	"- Check every condition in the instruction before any action with side effects. If a condition is not met or cannot be verified, stop before you act.",
+	"- A tool result with `timed_out: true` means that attempt did not finish. Before you retry work that may have side effects, inspect authoritative state and do not repeat a mutation that already applied.",
+	`- Assistant text is never delivered. End the run with \`${FINISH_AUTOMATION_RUN_TOOL_NAME}\`. Do not post the result with another tool.`
+];
 const SAFETY_RULES = [
 	"- Stay within the user's request and the runtime's available capabilities; do not pursue independent goals, persistence, replication, credential gathering, or access expansion.",
 	"- Respect stop, pause, audit, and approval boundaries. Do not bypass safeguards or persuade the user to weaken them.",
 	"- Do not change system prompts, tool policies, security settings, credentials, or runtime configuration unless the user explicitly requests that exact administrative action and an available tool permits it."
 ];
+const AUTOMATION_FAILURE_RULES = ["- Keep commands, error output, raw tool payloads, and internal routing metadata out of the message.", `- When a failure stops the job, put its cause in the \`${FINISH_AUTOMATION_RUN_TOOL_NAME}\` reason, not in the message.`];
 const FAILURE_RULES = [
 	"- For tool/runtime failures, run the named check before diagnosing and report the exact failed command plus stderr/exit code.",
 	"- If a fact cannot be verified after focused checks, say what you checked and what blocked a stronger answer.",
@@ -1758,21 +1890,33 @@ function renderRuleSection(tag, lines) {
 		`</${tag}>`
 	].join("\n");
 }
-function buildBehaviorSection(platform) {
-	const sections = [
+function buildBehaviorSection(platform, mode) {
+	const runSections = mode === "automation" ? [renderRuleSection("automation-run", AUTOMATION_RUN_RULES)] : [
+		renderRuleSection("task-execution", TASK_EXECUTION_RULES),
+		renderRuleSection("conversation", CONVERSATION_RULES),
+		...platform === "slack" ? [renderRuleSection("slack-actions", SLACK_ACTION_RULES)] : []
+	];
+	const automation = mode === "automation";
+	return [
 		renderRuleSection("tool-policy", TOOL_POLICY_RULES),
-		renderRuleSection("tool-call-style", TOOL_CALL_STYLE_RULES),
+		...automation ? [] : [renderRuleSection("tool-call-style", TOOL_CALL_STYLE_RULES)],
 		renderRuleSection("skill-policy", SKILL_POLICY_RULES),
 		renderRuleSection("planning", PLANNING_RULES),
-		renderRuleSection("task-execution", TASK_EXECUTION_RULES),
-		renderRuleSection("conversation", CONVERSATION_RULES),
+		...runSections,
 		renderRuleSection("safety", SAFETY_RULES),
-		renderRuleSection("failure-handling", FAILURE_RULES)
-	];
-	if (platform === "slack") sections.splice(6, 0, renderRuleSection("slack-actions", SLACK_ACTION_RULES));
-	return sections.join("\n\n");
+		renderRuleSection("failure-handling", automation ? AUTOMATION_FAILURE_RULES : FAILURE_RULES)
+	].join("\n\n");
+}
+function buildAutomationOutputSection(platform) {
+	return [
+		platform === "slack" ? `<output format="slack-markdown">` : `<output format="markdown">`,
+		"- Follow any format in the instruction. Otherwise keep the message as short as the job allows, and do not describe the run.",
+		platform === "slack" ? "- Use Slack-flavored Markdown: **bold** section labels, `code`, [text](url) links, bullet lists, and fenced code blocks. No hash-prefixed headings and no tables." : "- Use concise Markdown: short paragraphs, bullets, links, and fenced code blocks.",
+		"</output>"
+	].join("\n");
 }
-function buildOutputSection(platform) {
+function buildOutputSection(platform, mode) {
+	if (mode === "automation") return buildAutomationOutputSection(platform);
 	if (platform === "local") return [
 		`<output format="markdown">`,
 		"- Start with the answer or result, not internal process narration.",
@@ -1840,13 +1984,22 @@ function formatDestinationLines(destination) {
 		`- destination.channel_id: ${escapeXml(destination.channelId)}`
 	];
 }
+function formatOutcomeLines(outcomes) {
+	if (!outcomes) return ["- dispatch.outcomes: send_message to the destination below (legacy default)"];
+	if (outcomes.length === 0) return ["- dispatch.outcomes: none; successful work posts nothing"];
+	return outcomes.map((outcome, index) => {
+		const { channelId, threadTs } = outcome.destination;
+		const recipient = isDmChannel$1(channelId) ? "the creator's direct message" : "a slack channel";
+		const target = [`channel_id=${escapeXml(channelId)}`, ...threadTs ? [`thread_ts=${escapeXml(threadTs)}`] : []].join(" ");
+		return `- dispatch.outcome.${index + 1}: ${outcome.action} to ${recipient} (${target})`;
+	});
+}
 function buildDispatchSection(params) {
 	if (!params) return null;
 	const metadataLines = Object.entries(params.metadata ?? {}).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `- dispatch.metadata.${escapeXml(key)}: ${escapeXml(value)}`);
 	return renderTag("dispatch", [
 		"- dispatch.execution: execute the dispatched input now",
-		"- dispatch.delivery: the runtime delivers the final answer to the destination",
-		"- dispatch.delivery_rule: do not request or require a separate posting tool just to deliver the final answer",
+		...params.declaresResult ? formatOutcomeLines(params.outcomes) : ["- dispatch.delivery: the runtime delivers the final answer to the destination", "- dispatch.delivery_rule: do not request or require a separate posting tool just to deliver the final answer"],
 		...params.actor ? [`- dispatch.actor.platform: ${escapeXml(params.actor.platform)}`, `- dispatch.actor.name: ${escapeXml(params.actor.name)}`] : [],
 		...params.plugin ? [`- dispatch.plugin: ${escapeXml(params.plugin)}`] : [],
 		...formatSourceLines(params.source),
@@ -1896,23 +2049,29 @@ function buildPluginSystemPromptContributions(contributions) {
 	for (const contribution of contributions) lines.push(`  <plugin-contribution plugin="${escapeXml(contribution.pluginName)}" id="${escapeXml(contribution.id)}">`, escapeXml(contribution.text.trim()), "  </plugin-contribution>");
 	return renderTagBlock("plugin-system-context", lines.join("\n"));
 }
-function buildStaticSystemPrompt(platform) {
+function buildStaticSystemPrompt(platform, mode) {
 	return [
 		platform === "slack" ? SLACK_HEADER : LOCAL_HEADER,
 		buildIdentitySection(platform),
 		buildPersonalitySection(),
 		buildWorldSection(),
-		buildBehaviorSection(platform),
-		buildOutputSection(platform)
+		buildBehaviorSection(platform, mode),
+		buildOutputSection(platform, mode)
 	].filter((section) => Boolean(section)).join("\n\n");
 }
 const STATIC_SYSTEM_PROMPTS = {
-	local: buildStaticSystemPrompt("local"),
-	slack: buildStaticSystemPrompt("slack")
+	automation: {
+		local: buildStaticSystemPrompt("local", "automation"),
+		slack: buildStaticSystemPrompt("slack", "automation")
+	},
+	conversation: {
+		local: buildStaticSystemPrompt("local", "conversation"),
+		slack: buildStaticSystemPrompt("slack", "conversation")
+	}
 };
-/** Return the fixed instructions shared by every Conversation and Turn. */
-function buildSystemPrompt(platform) {
-	return STATIC_SYSTEM_PROMPTS[platform];
+/** Return the fixed instructions for one platform and prompt mode. */
+function buildSystemPrompt(platform, mode = "conversation") {
+	return STATIC_SYSTEM_PROMPTS[mode][platform];
 }
 /** Build volatile runtime context that belongs in the user turn, not the system prompt. */
 function buildTurnContextPrompt(params) {
@@ -2199,9 +2358,10 @@ async function assemblePrompt(args) {
 		userContentParts: requestContentParts
 	}) : void 0;
 	const needsBootstrapContextForPrompt = shouldPromptAgent && !replayedPrompt && !hasRuntimeTurnContext(promptHistoryMessages);
-	const platform = args.run.delivery && args.run.location?.provider === "slack" ? "slack" : "local";
+	const promptMode = args.run.dispatch?.declaresResult ? "automation" : "conversation";
+	const platform = (args.run.delivery || promptMode === "automation") && args.run.location?.provider === "slack" ? "slack" : "local";
 	const pluginSystemPrompt = buildPluginSystemPromptContributions(await getPluginSystemPromptContributions(platform));
-	const baseInstructions = [buildSystemPrompt(platform), pluginSystemPrompt].filter((section) => Boolean(section)).join("\n\n");
+	const baseInstructions = [buildSystemPrompt(platform, promptMode), pluginSystemPrompt].filter((section) => Boolean(section)).join("\n\n");
 	const pluginUserPromptContributions = !shouldPromptAgent || replayedPrompt ? [] : await getPluginUserPromptContributions({
 		context: args.toolRuntimeContext,
 		turnId: args.turnId
@@ -2660,541 +2820,6 @@ function formatSandboxCommandResult(params) {
 	});
 }
 //#endregion
-//#region src/chat/slack/post-warning.ts
-const codes = /* @__PURE__ */ new Set([
-	"invalid_metadata_format",
-	"invalid_metadata_schema",
-	"metadata_too_large",
-	"invalid_arguments",
-	"invalid_blocks",
-	"missing_scope",
-	"missing_charset",
-	"superfluous_charset",
-	"message_truncated"
-]);
-const pathFields = /* @__PURE__ */ new Set([
-	"metadata",
-	"event_type",
-	"event_payload",
-	"entities",
-	"entity_type",
-	"entity_payload",
-	"external_ref",
-	"id",
-	"type",
-	"url",
-	"attributes",
-	"title",
-	"text",
-	"display_id",
-	"display_type",
-	"product_name",
-	"fields",
-	"status",
-	"custom_fields",
-	"key",
-	"label",
-	"value",
-	"long",
-	"format",
-	"link",
-	"display_order",
-	"app_unfurl_url",
-	"app_id",
-	"created_by",
-	"created_at",
-	"updated_by",
-	"updated_at",
-	"full_size_preview",
-	"preview_url",
-	"mime_type"
-]);
-const diagnosticWords = new Set(`WARN ERROR Message message metadata was incorrectly formatted The the will be
-  ignored as a result For for event entity refer to following errors error
-  missing required field fields property properties additional unexpected unknown
-  unsupported invalid expected received actual type types must should match matches
-  matching does not is are has have of at in on and or an only allowed allow
-  value values string number integer boolean object array null minimum maximum
-  length min max items item empty nonempty too long short large small size limit
-  exceeded exceeds less greater than equal valid format schema validation failed
-  failure cannot contain contains found one any all none enum pattern definition
-  defined constraint constraints satisfy satisfies with without provided specified
-  unrecognized unrecognised recognized recognised extraneous disallowed duplicate
-  unique malformed nested root exactly needs need requires requirement supported
-  json-pointer input different schema_uri schema_id schemas additionalProperties
-  minLength maxLength minItems maxItems anyOf oneOf allOf`.split(/\s+/));
-function summarizeDiagnostic(value) {
-	return value.slice(0, 2e3).replace(/\b(?:https?:\/\/|www\.)[^\s"'`<>]+/gi, "[value]").replace(/\/[^\s"'`[\],;()]*|[\p{L}\p{N}\p{M}_]+(?:[-./:@=+%~][\p{L}\p{N}\p{M}_]+)*|[^\s\w[\]{}():,;."'`/*=<>!?+-]/gu, (token) => {
-		if (token.startsWith("/")) return token.split("/").slice(0, 17).map((part, index) => index === 0 ? "" : pathFields.has(part) ? part : "*").join("/");
-		return codes.has(token) || pathFields.has(token) || diagnosticWords.has(token) ? token : "[value]";
-	}).replace(/\s+/g, " ").slice(0, 2e3);
-}
-/** Report Slack warnings once, on the request span, without retrying the post. */
-function captureSlackPostWarning(response, attributes) {
-	const warnings = response.response_metadata?.warnings ?? [];
-	const messages = response.response_metadata?.messages ?? [];
-	const knownCodes = [...new Set(warnings.slice(0, 20).filter((code) => codes.has(code)))].sort();
-	const diagnostics = {
-		"app.slack.warning_count": warnings.length,
-		"app.slack.response_message_count": messages.length,
-		"app.slack.diagnostic_codes": knownCodes
-	};
-	setSpanAttributes(diagnostics);
-	if (!warnings.length && !messages.length) return;
-	captureMessage("Slack chat.postMessage returned warnings", {
-		level: "warning",
-		fingerprint: ["slack.chat.postMessage.warning", ...knownCodes.length ? knownCodes : ["unknown"]],
-		tags: { "app.slack.method": "chat.postMessage" },
-		extra: {
-			...getLogContextAttributes(),
-			...attributes,
-			...diagnostics,
-			"app.slack.response_diagnostics": {
-				warnings: warnings.slice(0, 20).map(summarizeDiagnostic),
-				messages: messages.slice(0, 20).map(summarizeDiagnostic)
-			}
-		}
-	});
-}
-//#endregion
-//#region src/chat/slack/work-object.ts
-const url = z.url({ protocol: /^https?$/ });
-const textField = z.strictObject({
-	type: z.literal("string"),
-	key: z.string().min(1),
-	label: z.string().min(1),
-	value: z.string(),
-	long: z.boolean().optional(),
-	format: z.literal("markdown").optional(),
-	link: url.optional()
-}).refine((field) => !field.format || !field.link, { message: "Slack string fields cannot combine format and link" });
-const customField = z.discriminatedUnion("type", [textField, z.strictObject({
-	type: z.literal("slack#/types/timestamp"),
-	key: z.string().min(1),
-	label: z.string().min(1),
-	value: z.number().int(),
-	link: url.optional()
-})]);
-const payload = z.strictObject({
-	attributes: z.strictObject({
-		title: z.strictObject({ text: z.string().min(1) }),
-		display_id: z.string().optional(),
-		display_type: z.string().optional(),
-		product_name: z.string().optional(),
-		product_icon: z.strictObject({
-			url,
-			alt_text: z.string().min(1)
-		}).optional()
-	}),
-	custom_fields: z.array(customField).optional(),
-	display_order: z.array(z.string()).optional()
-});
-/** Limit IDs to Junior's safe subset; Slack silently rejects JSON punctuation. */
-const slackExternalRefIdSchema = z.string().min(1).regex(/^[A-Za-z0-9_-]+$/, "Unsupported Slack external reference ID");
-const entity = z.strictObject({
-	external_ref: z.strictObject({
-		id: slackExternalRefIdSchema,
-		type: z.string().min(1).optional()
-	}),
-	url
-});
-/** Validate notification and detail metadata before Slack can ignore bad fields. */
-const slackEntitySchema = z.discriminatedUnion("entity_type", [entity.extend({
-	entity_type: z.literal("slack#/entities/item"),
-	entity_payload: payload.extend({ fields: z.never().optional() })
-}), entity.extend({
-	entity_type: z.literal("slack#/entities/task"),
-	entity_payload: payload.extend({ fields: z.strictObject({ status: z.strictObject({ value: z.string() }).optional() }).optional() })
-})]);
-//#endregion
-//#region src/chat/slack/outbound.ts
-const MAX_SLACK_MESSAGE_TEXT_CHARS = 4e4;
-function requireSlackConversationId(channelId, action) {
-	const normalized = normalizeSlackConversationId(channelId);
-	if (!normalized) throw new Error(`${action} requires a valid channel ID`);
-	return normalized;
-}
-function requireSlackThreadTimestamp(threadTs, action) {
-	const normalized = threadTs.trim();
-	if (!normalized) throw new Error(`${action} requires a thread timestamp`);
-	return normalized;
-}
-function requireSlackMessageTimestamp(timestamp, action) {
-	const normalized = parseSlackMessageTs(timestamp);
-	if (!normalized) throw new Error(`${action} requires a target message timestamp`);
-	return normalized;
-}
-function requireSlackMessageText(text, action) {
-	if (text.trim().length === 0) throw new Error(`${action} requires non-empty text`);
-	if (text.length > MAX_SLACK_MESSAGE_TEXT_CHARS) throw new Error(`${action} text exceeds Slack's 40000 character truncation limit`);
-	return text;
-}
-/** Resolve a Slack message permalink without making read-only workflows fail on lookup errors. */
-async function getSlackMessagePermalink(args) {
-	try {
-		return (await withSlackRetries(() => getSlackClient().chat.getPermalink({
-			channel: args.channelId,
-			message_ts: args.messageTs
-		}), 3, {
-			action: "chat.getPermalink",
-			idempotent: true,
-			spanAttributes: {
-				"app.slack.channel_id": args.channelId,
-				"app.slack.message_ts": args.messageTs
-			}
-		})).permalink;
-	} catch {
-		return;
-	}
-}
-/** Post Slack `mrkdwn` text to a conversation or thread via the shared outbound boundary. */
-async function postSlackMessage(input) {
-	const channelId = requireSlackConversationId(input.channelId, "Slack message posting");
-	const text = requireSlackMessageText(input.text, "Slack message posting");
-	const entities = input.entities?.length ? slackEntitySchema.array().parse(input.entities) : void 0;
-	const threadTs = input.threadTs ? requireSlackThreadTimestamp(input.threadTs, "Slack thread message posting") : void 0;
-	const attributes = {
-		"app.slack.channel_id": channelId,
-		...threadTs ? { "app.slack.thread_ts": threadTs } : void 0,
-		"app.slack.work_object.count": entities?.length ?? 0
-	};
-	const response = await withSlackRetries(async () => {
-		const response = await getSlackClient().chat.postMessage({
-			channel: channelId,
-			text,
-			unfurl_links: false,
-			unfurl_media: false,
-			...input.blocks?.length ? { blocks: input.blocks } : void 0,
-			...entities ? { metadata: { entities } } : void 0,
-			...threadTs ? { thread_ts: threadTs } : void 0
-		});
-		const messageId = parseSlackMessageTs(response.ts);
-		setSpanAttributes({ "messaging.message.id": messageId });
-		captureSlackPostWarning(response, {
-			...attributes,
-			"messaging.message.id": messageId
-		});
-		return response;
-	}, 3, {
-		action: "chat.postMessage",
-		attributes
-	});
-	const messageTs = parseSlackMessageTs(response.ts);
-	if (!messageTs) throw new Error("Slack message posted without ts");
-	return {
-		ts: messageTs,
-		...input.includePermalink ? { permalink: await getSlackMessagePermalink({
-			channelId,
-			messageTs
-		}) } : void 0
-	};
-}
-/**
-* Post an ephemeral Slack message. Delivery is best-effort on Slack's side, but
-* request validation and Web API behavior are centralized here.
-*/
-async function postSlackEphemeralMessage(input) {
-	const channelId = requireSlackConversationId(input.channelId, "Slack ephemeral message posting");
-	const userId = parseSlackUserId(input.userId);
-	if (!userId) throw new Error("Slack ephemeral message posting requires a user ID");
-	const text = requireSlackMessageText(input.text, "Slack ephemeral message posting");
-	const threadTs = input.threadTs ? requireSlackThreadTimestamp(input.threadTs, "Slack ephemeral thread message posting") : void 0;
-	return { messageTs: (await withSlackRetries(() => getSlackClient().chat.postEphemeral({
-		channel: channelId,
-		user: userId,
-		text,
-		...input.blocks?.length ? { blocks: input.blocks } : void 0,
-		...threadTs ? { thread_ts: threadTs } : void 0
-	}), 3, {
-		action: "chat.postEphemeral",
-		spanAttributes: {
-			"app.slack.channel_id": channelId,
-			"app.slack.user_id": userId,
-			...threadTs ? { "app.slack.thread_ts": threadTs } : void 0
-		}
-	})).message_ts };
-}
-/** Upload files into a Slack conversation or thread via the shared outbound file boundary. */
-async function uploadFilesToConversation(input) {
-	const channelId = requireSlackConversationId(input.channelId, "Slack file upload");
-	const threadTs = input.threadTs ? requireSlackThreadTimestamp(input.threadTs, "Slack file upload") : void 0;
-	if (input.files.length === 0) throw new Error("Slack file upload requires at least one file");
-	const fileUploads = input.files.map((file) => {
-		const filename = file.filename.trim();
-		if (!filename) throw new Error("Slack file upload requires every file to have a filename");
-		return {
-			file: file.data,
-			filename
-		};
-	});
-	return { files: ((await withSlackRetries(() => getSlackClient().filesUploadV2({
-		channel_id: channelId,
-		...threadTs ? { thread_ts: threadTs } : void 0,
-		file_uploads: fileUploads
-	}), 3, {
-		action: "filesUploadV2",
-		spanAttributes: {
-			"app.slack.channel_id": channelId,
-			...threadTs ? { "app.slack.thread_ts": threadTs } : void 0
-		}
-	})).files ?? []).flatMap((completion) => (completion.files ?? []).map((file) => file.id ? { id: file.id } : {})) };
-}
-/** Add a reaction to a Slack message, treating `already_reacted` as idempotent success. */
-async function addReactionToMessage(input) {
-	const channelId = requireSlackConversationId(input.channelId, "Slack reaction");
-	const timestamp = requireSlackMessageTimestamp(input.timestamp, "Slack reaction");
-	const emoji = normalizeSlackEmojiName(input.emoji);
-	if (!emoji) throw new Error("Slack reaction requires a valid emoji alias name");
-	try {
-		await withSlackRetries(() => getSlackClient(input.timeoutMs === void 0 ? void 0 : { timeoutMs: input.timeoutMs }).reactions.add({
-			channel: channelId,
-			timestamp,
-			name: emoji
-		}), input.timeoutMs === void 0 ? 3 : 1, {
-			action: "reactions.add",
-			idempotent: true,
-			spanAttributes: {
-				"app.slack.channel_id": channelId,
-				"app.slack.message_ts": timestamp,
-				"app.slack.reaction": emoji
-			}
-		});
-	} catch (error) {
-		if (error instanceof SlackActionError && error.code === "already_reacted") return { ok: true };
-		throw error;
-	}
-	return { ok: true };
-}
-/** Remove a reaction from a Slack message, treating `no_reaction` as idempotent success. */
-async function removeReactionFromMessage(input) {
-	const channelId = requireSlackConversationId(input.channelId, "Slack reaction removal");
-	const timestamp = requireSlackMessageTimestamp(input.timestamp, "Slack reaction removal");
-	const emoji = normalizeSlackEmojiName(input.emoji);
-	if (!emoji) throw new Error("Slack reaction removal requires a valid emoji alias name");
-	try {
-		await withSlackRetries(() => getSlackClient().reactions.remove({
-			channel: channelId,
-			timestamp,
-			name: emoji
-		}), 3, {
-			action: "reactions.remove",
-			idempotent: true,
-			spanAttributes: {
-				"app.slack.channel_id": channelId,
-				"app.slack.message_ts": timestamp,
-				"app.slack.reaction": emoji
-			}
-		});
-	} catch (error) {
-		if (error instanceof SlackActionError && error.code === "no_reaction") return { ok: true };
-		throw error;
-	}
-	return { ok: true };
-}
-//#endregion
-//#region src/chat/slack/status-format.ts
-const SLACK_STATUS_MAX_LENGTH = 50;
-/** Truncate a status string to fit Slack's 50-char assistant status limit. */
-function truncateStatusText(text) {
-	const trimmed = text.trim();
-	if (!trimmed) return "";
-	if (trimmed.length <= SLACK_STATUS_MAX_LENGTH) return trimmed;
-	return `${trimmed.slice(0, 47).trimEnd()}...`;
-}
-//#endregion
-//#region src/chat/slack/mrkdwn.ts
-/** Escape dynamic text for Slack mrkdwn without changing intended formatting. */
-function escapeSlackMrkdwnText(text) {
-	return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
-}
-/** Escape a URL for Slack explicit link syntax while preserving query semantics. */
-function escapeSlackLinkUrl(url) {
-	return url.replaceAll("&", "&amp;").replaceAll("<", "%3C").replaceAll(">", "%3E");
-}
-/** Build a Slack explicit link from dynamic URL and label values. */
-function formatSlackLink(url, label) {
-	return `<${escapeSlackLinkUrl(url)}|${escapeSlackMrkdwnText(label)}>`;
-}
-function readInlineCodeSpan(line, start) {
-	if (line[start] !== "`") return;
-	let n = 1;
-	while (line[start + n] === "`") n++;
-	const marker = "`".repeat(n);
-	let search = start + n;
-	while (search < line.length) {
-		const close = line.indexOf(marker, search);
-		if (close === -1) return;
-		const after = close + n;
-		if (line[after] !== "`") return {
-			text: line.slice(start, after),
-			end: after
-		};
-		search = after + 1;
-	}
-}
-function readExistingSlackAngleToken(line, start) {
-	if (line[start] !== "<") return;
-	const close = line.indexOf(">", start + 1);
-	if (close === -1) return;
-	const body = line.slice(start + 1, close);
-	if (/^(?:https?:\/\/|@|#|!)/.test(body)) return {
-		text: line.slice(start, close + 1),
-		end: close + 1
-	};
-}
-function readMarkdownLink(line, start) {
-	if (line[start] !== "[") return;
-	const labelEnd = line.indexOf("](", start + 1);
-	if (labelEnd === -1) return;
-	const destStart = labelEnd + 2;
-	if (!line.startsWith("http://", destStart) && !line.startsWith("https://", destStart)) return;
-	const closeParens = line.indexOf(")", destStart);
-	if (closeParens === -1) return;
-	return {
-		text: line.slice(start, closeParens + 1),
-		end: closeParens + 1
-	};
-}
-function hasUnmatchedClosingParen(text) {
-	let balance = 0;
-	for (const ch of text) if (ch === "(") balance++;
-	else if (ch === ")") balance--;
-	return balance < 0;
-}
-function readBareUrl(line, start) {
-	let end = start;
-	while (end < line.length) {
-		const ch = line[end];
-		if (/\s/.test(ch) || ch === "<" || ch === ">" || ch === "\"" || ch === "`" || ch === "|" || ch === "*") break;
-		end++;
-	}
-	if (end === start) return;
-	let raw = line.slice(start, end);
-	let suffix = "";
-	const peel = () => {
-		suffix = raw.slice(-1) + suffix;
-		raw = raw.slice(0, -1);
-	};
-	const shouldPeel = () => raw.endsWith("_") || /[.,!?;:]$/.test(raw) || raw.endsWith(")") && hasUnmatchedClosingParen(raw);
-	while (raw.length > 0 && shouldPeel()) peel();
-	if (!/^https?:\/\/.+/.test(raw)) return;
-	return {
-		url: raw,
-		suffix,
-		end
-	};
-}
-/** Wrap bare http(s) URLs on a single line as Slack explicit `<url>` links. */
-function wrapBareUrlsOnLine(line) {
-	let result = "";
-	let i = 0;
-	while (i < line.length) {
-		const codeSpan = readInlineCodeSpan(line, i);
-		if (codeSpan) {
-			result += codeSpan.text;
-			i = codeSpan.end;
-			continue;
-		}
-		const angleToken = readExistingSlackAngleToken(line, i);
-		if (angleToken) {
-			result += angleToken.text;
-			i = angleToken.end;
-			continue;
-		}
-		const mdLink = readMarkdownLink(line, i);
-		if (mdLink) {
-			result += mdLink.text;
-			i = mdLink.end;
-			continue;
-		}
-		if (line.startsWith("https://", i) || line.startsWith("http://", i)) {
-			const parsed = readBareUrl(line, i);
-			if (parsed) {
-				result += `<${parsed.url}>${parsed.suffix}`;
-				i = parsed.end;
-				continue;
-			}
-		}
-		result += line[i];
-		i++;
-	}
-	return result;
-}
-/**
-* Pre-wrap bare http(s) URLs outside fenced code blocks as Slack explicit
-* links, preventing Slack's auto-linker from consuming adjacent formatting
-* markers into the URL.
-*
-* Uses the same fence-toggle rule as `ensureBlockSpacing` so both passes
-* agree on which lines are code.
-*/
-function wrapBareUrls(text) {
-	const lines = text.split("\n");
-	const out = [];
-	let inCodeBlock = false;
-	for (const line of lines) {
-		if (line.trimStart().startsWith("```")) {
-			inCodeBlock = !inCodeBlock;
-			out.push(line);
-			continue;
-		}
-		out.push(inCodeBlock ? line : wrapBareUrlsOnLine(line));
-	}
-	return out.join("\n");
-}
-/** Insert blank lines between content blocks so Slack renders them with visual separation. */
-function ensureBlockSpacing(text) {
-	const codeBlockPattern = /^```/;
-	const listItemPattern = /^[-*•]\s|^\d+\.\s/;
-	const lines = text.split("\n");
-	const result = [];
-	let inCodeBlock = false;
-	for (let i = 0; i < lines.length; i++) {
-		const line = lines[i];
-		if (codeBlockPattern.test(line.trimStart())) {
-			if (!inCodeBlock) {
-				const prev = result.length > 0 ? result[result.length - 1] : void 0;
-				if (prev !== void 0 && prev.trim() !== "") result.push("");
-			}
-			inCodeBlock = !inCodeBlock;
-			result.push(line);
-			continue;
-		}
-		if (inCodeBlock) {
-			result.push(line);
-			continue;
-		}
-		const prev = result.length > 0 ? result[result.length - 1] : void 0;
-		if (prev !== void 0 && prev.trim() !== "" && line.trim() !== "" && !(listItemPattern.test(prev.trimStart()) && listItemPattern.test(line.trimStart()))) result.push("");
-		result.push(line);
-	}
-	return result.join("\n");
-}
-/**
-* Normalize model-authored Slack markdown for delivery via `markdown_text`
-* or `{ type: "markdown" }` blocks.
-*
-* Plugins may first rewrite ordinary Markdown. Core then applies Slack-only
-* delivery shaping: bare URL wrapping and block spacing. Slack reply delivery
-* owns chunking and continuation markers separately.
-*/
-function normalizeSlackReplyMarkdown(text) {
-	let normalized = applyPluginFormatMarkdown(text).replace(/\r\n?/g, "\n").replace(/[ \t]+$/gm, "");
-	normalized = wrapBareUrls(normalized);
-	normalized = ensureBlockSpacing(normalized);
-	return normalized.replace(/\n{3,}/g, "\n\n").trim();
-}
-/** Normalize assistant status text before handing it to Slack. */
-function normalizeSlackStatusText(text) {
-	const trimmed = text.trim();
-	if (!trimmed) return "";
-	return truncateStatusText(trimmed.replace(/(?:\.\s*)+$/, "").trim());
-}
-/** Render a Slack user mention, which Slack shows as the person's name. */
-function slackMention(userId) {
-	return `<@${userId}>`;
-}
-//#endregion
 //#region src/chat/slack/oauth-authorization-message.ts
 const ACCOUNT_SCOPE_NOTE = "This connects only your account. Junior sees only what you can see.";
 /** Present private OAuth authorization with a clear action and text fallback. */
@@ -4063,10 +3688,13 @@ async function maybePostAutomatedTurnLimitNotice(args) {
 }
 //#endregion
 //#region src/chat/task-input.ts
-/** Shared closing lines for the stored outcomes. */
+/**
+* Shared closing lines. Automations pass outcomes and end with a declared
+* result. Watches pass no outcomes and reply in the Conversation.
+*/
 function replyContractLines(outcomes) {
-	if (outcomes?.length === 0) return ["Do the work without writing a status message.", "No successful output will be delivered."];
-	return ["When you reply, follow any reply format in the instructions.", "Briefly report what you did or what is needed next."];
+	if (!outcomes) return ["When you reply, follow any reply format in the instructions.", "Briefly report what you did or what is needed next."];
+	return [`End with \`${FINISH_AUTOMATION_RUN_TOOL_NAME}\`.`];
 }
 function oneLine(value) {
 	return value.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim();
@@ -4091,7 +3719,7 @@ function renderTaskInput(args) {
 		"This is a task, not a message from a person.",
 		"",
 		...about ? [`About: ${oneLine(about)}`] : [],
-		...creator ? [`Created by: ${oneLine(creator)}. Where the instructions say "me" or "my", write this mention.`] : [],
+		...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.`] : [],
 		`Instructions: ${instructions}`
 	];
 	const guidance = args.guidance?.trim();
@@ -10088,6 +9716,44 @@ function createSpawnAgentTool(spawnAgent) {
 	});
 }
 //#endregion
+//#region src/chat/tools/runtime/finish-automation-run.ts
+const RESULT_GUIDANCE = ["Use `no_action` when the run worked and nothing should be posted, such as when a condition in the instruction is not met, or when a temporary failure stopped the work.", "Use `misconfigured` when the run cannot do its job until its creator changes the automation: a provider, tool, account, or access that the job needs is missing, a target no longer exists, or the instruction cannot be done. Do not use it for a temporary failure or a condition that is not met."].join(" ");
+/** Create the tool that ends one Automation run with a declared result. */
+function createFinishAutomationRunTool(options) {
+	const results = options.sendsMessage ? [
+		"send_message",
+		"no_action",
+		"misconfigured"
+	] : ["no_action", "misconfigured"];
+	return zodTool({
+		annotations: {
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false,
+			readOnlyHint: false
+		},
+		description: options.sendsMessage ? `End this automation run. Use \`send_message\` with the finished reminder, digest, alert, or answer; the runtime posts it to the stored destinations. ${RESULT_GUIDANCE}` : `End this automation run. This automation posts nothing. ${RESULT_GUIDANCE}`,
+		inputSchema: z.object({
+			result: z.enum(results),
+			...options.sendsMessage ? { message: z.string().optional().describe("Required for send_message. The text to post.") } : void 0,
+			reason: z.string().optional().describe("Required for no_action and misconfigured. One sentence for the creator.")
+		}),
+		outputSchema: juniorToolOutputSchema.extend({ result: z.enum([
+			"send_message",
+			"no_action",
+			"misconfigured"
+		]) }),
+		execute: async (input) => {
+			const parsed = automationResultSchema.safeParse(input);
+			if (!parsed.success) throw new ToolInputError(input.result === "send_message" ? "send_message requires a non-empty message." : `${input.result} requires a non-empty reason.`);
+			return parsed.data.result === "send_message" && isNoReplyMarker(parsed.data.message) ? {
+				result: "no_action",
+				reason: "The message was the no-reply marker."
+			} : parsed.data;
+		}
+	});
+}
+//#endregion
 //#region src/chat/tools/list-watches.ts
 const listedResourceWatchSchema = z.object({
 	id: z.string().min(1),
@@ -10432,305 +10098,6 @@ function requireRequesterMention(instruction, actor) {
 	if (namesPerson(instruction, actor.fullName)) throw new ToolInputError(`The instruction names ${actor.fullName} without a Slack mention. Write ${mention} for this person.`);
 }
 //#endregion
-//#region src/chat/automations/revision.ts
-/** Storage revisions prevent stale edits from replacing newer values. */
-var AutomationConflictError = class extends ToolInputError {
-	constructor() {
-		super("This Automation changed after it was loaded. Reload it before saving.");
-		this.name = "AutomationConflictError";
-	}
-};
-/** Sort object keys so equal values produce equal JSON. */
-function canonicalJson$1(value) {
-	if (Array.isArray(value)) return value.map(canonicalJson$1);
-	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, child]) => [key, canonicalJson$1(child)]));
-	return value;
-}
-/** Identify the stored values being edited, including lifecycle and creator authority. */
-function automationRevision(task) {
-	return createHash("sha256").update(JSON.stringify(canonicalJson$1(task))).digest("hex");
-}
-/** Reject a stale edit while the storage owner holds the write lock. */
-function requireAutomationRevision(task, revision) {
-	if (!task || automationRevision(task) !== revision) throw new AutomationConflictError();
-}
-//#endregion
-//#region src/chat/automations/versions.ts
-/** Automation versions keep each saved definition so people can see how it changed. */
-/** Return the versioned part of an Automation. Lifecycle and run state are excluded. */
-function automationDefinition(task) {
-	const common = {
-		title: task.title?.trim() || null,
-		instruction: task.task.text,
-		credentialMode: task.credentialMode,
-		destination: task.destination,
-		outcomes: task.outcomes
-	};
-	return "schedule" in task ? {
-		...common,
-		schedule: task.schedule
-	} : {
-		...common,
-		trigger: task.trigger
-	};
-}
-/** Compare definition values after key sorting. */
-function sameDefinitionValue(left, right) {
-	return JSON.stringify(canonicalJson$1(left)) === JSON.stringify(canonicalJson$1(right));
-}
-/**
-* Save a version when the definition changed. Call this in the same
-* transaction and lock as the Automation write. Without `current`, the
-* Automation is new, so the creator saves version 1.
-*/
-async function recordAutomationVersion(db, kind, task, current, editedBy) {
-	const definition = automationDefinition(task);
-	if (current && sameDefinitionValue(automationDefinition(current), definition)) return;
-	await db.insert(juniorAutomationVersions).values({
-		kind,
-		automationId: task.id,
-		version: sql`(
-      SELECT coalesce(max(${juniorAutomationVersions.version}), 0) + 1
-      FROM ${juniorAutomationVersions}
-      WHERE ${juniorAutomationVersions.kind} = ${kind}
-        AND ${juniorAutomationVersions.automationId} = ${task.id}
-    )`,
-		createdAtMs: Date.now(),
-		editedBy: editedBy ?? (current ? null : task.createdBy),
-		definition
-	});
-}
-function parseVersionRow(kind, row) {
-	return automationVersionSchema.parse({
-		kind,
-		version: row.version,
-		createdAt: new Date(row.createdAtMs).toISOString(),
-		editedBy: row.editedBy,
-		definition: row.definition
-	});
-}
-/** Read one saved definition. */
-async function readAutomationVersion(db, kind, automationId, version) {
-	const [row] = await db.select().from(juniorAutomationVersions).where(and(eq(juniorAutomationVersions.kind, kind), eq(juniorAutomationVersions.automationId, automationId), eq(juniorAutomationVersions.version, version))).limit(1);
-	return row ? parseVersionRow(kind, row) : void 0;
-}
-/** Read saved definitions, newest first. */
-async function listAutomationVersions(db, kind, automationId, limit) {
-	return (await db.select().from(juniorAutomationVersions).where(and(eq(juniorAutomationVersions.kind, kind), eq(juniorAutomationVersions.automationId, automationId))).orderBy(desc(juniorAutomationVersions.version)).limit(limit)).map((row) => parseVersionRow(kind, row));
-}
-//#endregion
-//#region src/chat/event-automations/store.ts
-const retainedEventAutomationSchema = eventAutomationSchema.extend({
-	destination: slackDestinationSchema,
-	outcomes: z.array(taskOutcomeSchema).max(5)
-});
-/** JSON task payload must not carry SQL-backed columns. */
-function eventAutomationJsonPayload(task) {
-	const { status: _status, title: _title, ...payload } = task;
-	return payload;
-}
-/** Decode a retained event Automation with its SQL-backed fields. */
-function parseEventAutomationRow(row) {
-	const raw = row.task && typeof row.task === "object" ? { ...row.task } : row.task;
-	if (raw && typeof raw === "object" && "title" in raw) delete raw.title;
-	if (raw && typeof raw === "object" && !("outcomes" in raw) && "destination" in raw) raw.outcomes = [{
-		action: "send_message",
-		destination: raw.destination
-	}];
-	const retained = retainedEventAutomationSchema.parse(raw);
-	const { threadTs: _threadTs, ...destination } = retained.destination;
-	const title = row.title?.trim();
-	return {
-		...retained,
-		destination,
-		outcomes: retained.outcomes.map((outcome) => {
-			const { threadTs: _threadTs, ...destination } = outcome.destination;
-			return {
-				...outcome,
-				destination
-			};
-		}),
-		status: row.status ?? "active",
-		...title ? { title } : void 0
-	};
-}
-function activeEventAutomationWhere() {
-	return ne(juniorEventAutomations.status, "deleted");
-}
-/** Read one event automation by id, including deleted rows when present. */
-async function getEventAutomation(db, id) {
-	const rows = await db.select({
-		status: juniorEventAutomations.status,
-		task: juniorEventAutomations.task,
-		title: juniorEventAutomations.title
-	}).from(juniorEventAutomations).where(eq(juniorEventAutomations.id, id)).limit(1);
-	return rows[0] ? parseEventAutomationRow(rows[0]) : void 0;
-}
-/** Create one retry-stable event automation, or revive a deleted row with the new payload. */
-async function createEventAutomation(db, task) {
-	const parsed = eventAutomationSchema.parse(eventAutomationJsonPayload(task));
-	const title = task.title?.trim() || null;
-	return db.transaction(async (tx) => {
-		const inserted = await tx.insert(juniorEventAutomations).values({
-			id: parsed.id,
-			teamId: parsed.destination.teamId,
-			namespace: parsed.trigger.namespace,
-			identifier: parsed.trigger.identifier,
-			createdAtMs: parsed.createdAtMs,
-			status: "active",
-			title,
-			task: parsed
-		}).onConflictDoNothing().returning({
-			status: juniorEventAutomations.status,
-			task: juniorEventAutomations.task,
-			title: juniorEventAutomations.title
-		});
-		if (inserted[0]) {
-			const created = parseEventAutomationRow(inserted[0]);
-			await recordAutomationVersion(tx, "event", created, void 0);
-			return created;
-		}
-		const existing = await getEventAutomation(tx, parsed.id);
-		if (!existing) return {
-			...parsed,
-			status: "active",
-			...title ? { title } : void 0
-		};
-		if (existing.status !== "deleted") return existing;
-		const rows = await tx.update(juniorEventAutomations).set({
-			teamId: parsed.destination.teamId,
-			namespace: parsed.trigger.namespace,
-			identifier: parsed.trigger.identifier,
-			status: "active",
-			title,
-			task: parsed
-		}).where(and(eq(juniorEventAutomations.id, parsed.id), eq(juniorEventAutomations.status, "deleted"))).returning({
-			status: juniorEventAutomations.status,
-			task: juniorEventAutomations.task,
-			title: juniorEventAutomations.title
-		});
-		if (!rows[0]) return await getEventAutomation(tx, parsed.id) ?? {
-			...parsed,
-			status: "active",
-			...title ? { title } : void 0
-		};
-		const revived = parseEventAutomationRow(rows[0]);
-		await recordAutomationVersion(tx, "event", revived, void 0);
-		return revived;
-	});
-}
-/**
-* Replace an existing non-deleted event automation under a row lock.
-* Pass `editedBy` when a person changes the definition so its version names them.
-*/
-async function saveEventAutomation(db, task, expectedRevision, editedBy) {
-	const parsed = eventAutomationSchema.parse(eventAutomationJsonPayload(task));
-	const title = task.title?.trim() || null;
-	return db.transaction(async (tx) => {
-		const rows = await tx.select({
-			status: juniorEventAutomations.status,
-			task: juniorEventAutomations.task,
-			title: juniorEventAutomations.title
-		}).from(juniorEventAutomations).where(eq(juniorEventAutomations.id, parsed.id)).for("update");
-		const current = rows[0] ? parseEventAutomationRow(rows[0]) : void 0;
-		if (expectedRevision !== void 0) requireAutomationRevision(current, expectedRevision);
-		if (!current || current.status === "deleted") return void 0;
-		const saved = parseEventAutomationRow((await tx.update(juniorEventAutomations).set({
-			namespace: parsed.trigger.namespace,
-			identifier: parsed.trigger.identifier,
-			title,
-			task: parsed
-		}).where(eq(juniorEventAutomations.id, parsed.id)).returning({
-			status: juniorEventAutomations.status,
-			task: juniorEventAutomations.task,
-			title: juniorEventAutomations.title
-		}))[0]);
-		await recordAutomationVersion(tx, "event", saved, current, editedBy);
-		return saved;
-	});
-}
-/** Mark one existing event automation deleted while retaining the row for history. */
-async function deleteEventAutomation(db, id) {
-	const rows = await db.update(juniorEventAutomations).set({ status: "deleted" }).where(and(eq(juniorEventAutomations.id, id), activeEventAutomationWhere())).returning({
-		status: juniorEventAutomations.status,
-		task: juniorEventAutomations.task,
-		title: juniorEventAutomations.title
-	});
-	return rows[0] ? parseEventAutomationRow(rows[0]) : void 0;
-}
-/** List live event automations in one Slack workspace. */
-async function listEventAutomationsForTeam(db, teamId) {
-	return (await db.select({
-		status: juniorEventAutomations.status,
-		task: juniorEventAutomations.task,
-		title: juniorEventAutomations.title
-	}).from(juniorEventAutomations).where(and(eq(juniorEventAutomations.teamId, teamId), activeEventAutomationWhere())).orderBy(asc(juniorEventAutomations.createdAtMs), asc(juniorEventAutomations.id))).map(parseEventAutomationRow);
-}
-function viewerSlackIdentities(user) {
-	return user.identities.filter((identity) => identity.provider === "slack" && Boolean(identity.providerTenantId) && Boolean(identity.providerSubjectId));
-}
-/** Return whether one event automation was created by a viewer-linked Slack identity. */
-function eventAutomationBelongsToUser(task, user) {
-	return viewerSlackIdentities(user).some((identity) => identity.providerTenantId === task.destination.teamId && identity.providerSubjectId === task.createdBy.slackUserId);
-}
-/**
-* List deleted event automations created by one user, newest first.
-* Used only to keep historical runs after the live automation list drops the row.
-*/
-async function listDeletedEventAutomationsCreatedBy(db, user, limit) {
-	const identities = viewerSlackIdentities(user);
-	const ownership = or(...identities.map((identity) => and(eq(juniorEventAutomations.teamId, identity.providerTenantId), sql`${juniorEventAutomations.task}->'createdBy'->>'slackUserId' = ${identity.providerSubjectId}`)));
-	if (!ownership) return [];
-	return (await db.select({
-		status: juniorEventAutomations.status,
-		task: juniorEventAutomations.task,
-		title: juniorEventAutomations.title
-	}).from(juniorEventAutomations).where(and(ownership, eq(juniorEventAutomations.status, "deleted"))).orderBy(desc(juniorEventAutomations.createdAtMs), desc(juniorEventAutomations.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.
-*/
-async function collectEventAutomationMatchKeys(db, input) {
-	const eventTypes = new Set(input.eventTypes.map((eventType) => eventType.trim()).filter(Boolean));
-	const identifiers = [...new Set(input.identifiers.map((value) => value.trim()).filter(Boolean))];
-	if (eventTypes.size === 0 || identifiers.length === 0) return [];
-	const rows = await db.select({
-		status: juniorEventAutomations.status,
-		task: juniorEventAutomations.task,
-		title: juniorEventAutomations.title
-	}).from(juniorEventAutomations).where(and(eq(juniorEventAutomations.teamId, input.teamId), eq(juniorEventAutomations.namespace, input.namespace), inArray(juniorEventAutomations.identifier, identifiers), eq(juniorEventAutomations.status, "active"))).orderBy(asc(juniorEventAutomations.createdAtMs), asc(juniorEventAutomations.id));
-	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 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({
-		status: juniorEventAutomations.status,
-		task: juniorEventAutomations.task,
-		title: juniorEventAutomations.title
-	}).from(juniorEventAutomations).where(and(eq(juniorEventAutomations.teamId, teamId), eq(juniorEventAutomations.namespace, event.namespace), eq(juniorEventAutomations.identifier, event.identifier), eq(juniorEventAutomations.status, "active"))).orderBy(asc(juniorEventAutomations.createdAtMs), asc(juniorEventAutomations.id))).map(parseEventAutomationRow).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 credentials. */
-async function setEventAutomationStatus(db, id, status, revision) {
-	return db.transaction(async (tx) => {
-		const rows = await tx.select().from(juniorEventAutomations).where(eq(juniorEventAutomations.id, id)).for("update");
-		const current = rows[0] ? parseEventAutomationRow(rows[0]) : void 0;
-		requireAutomationRevision(current, revision);
-		if (!current || current.status === "deleted") throw new Error("Automation no longer exists.");
-		await tx.update(juniorEventAutomations).set({ status }).where(eq(juniorEventAutomations.id, id));
-		return {
-			...current,
-			status
-		};
-	});
-}
-//#endregion
 //#region src/chat/task-outcomes.ts
 /** Resolve explicit message outcomes to the Slack Destinations stored on an Automation. */
 async function resolveTaskOutcomes(outcomes, currentDestination, creatorSlackUserId) {
@@ -10744,9 +10111,7 @@ async function resolveTaskOutcomes(outcomes, currentDestination, creatorSlackUse
 			});
 			continue;
 		}
-		const userId = creatorSlackUserId;
-		const channelId = (await withSlackRetries(() => getSlackClient().conversations.open({ users: userId }), 3, { action: "conversations.open" })).channel?.id;
-		if (!channelId) throw new Error("Slack did not return a direct message destination.");
+		const channelId = await openSlackDirectMessage(creatorSlackUserId);
 		resolved.push({
 			action: "send_message",
 			destination: {
@@ -10781,9 +10146,11 @@ const compactEventAutomationResultSchema = z.object({
 	id: z.string().min(1),
 	status: z.enum([
 		"active",
+		"blocked",
 		"paused",
 		"deleted"
 	]),
+	statusReason: z.string().nullable(),
 	title: z.string().min(1).nullable(),
 	dashboardUrl: z.string().url().nullable(),
 	instruction: z.string().min(1),
@@ -10884,6 +10251,7 @@ function compactEventAutomation(task, catalog, requesterSlackUserId) {
 	return compactEventAutomationResultSchema.parse({
 		id: task.id,
 		status: task.status,
+		statusReason: task.statusReason ?? null,
 		title: task.title?.trim() || null,
 		dashboardUrl: getDashboardTaskLink(task.id) ?? null,
 		instruction: task.task.text,
@@ -11172,23 +10540,25 @@ function createUpdateEventAutomationTool(context, catalog) {
 			readOnlyHint: false
 		},
 		executionMode: "sequential",
-		description: "Update the instruction, registered trigger, or credential use for an event automation.",
+		description: "Update the instruction, registered trigger, credential use, or status of an event automation.",
 		inputSchema: z.object({
 			automationId: z.string().min(1),
 			title: automationTitleSchema.optional(),
 			instruction: automationInstructionToolSchema.nullable().optional(),
 			trigger: registeredEventAutomationTriggerSchema(catalog).nullable().optional(),
 			outcomes: z.array(taskOutcomeInputSchema).max(5).nullable().describe("Replacement messages to send after successful work. Use an empty list to send nothing. Omit or use null to leave unchanged.").optional(),
-			credentialMode: z.enum(["system", "creator"]).nullable().describe("Set creator to make the task's original creator credentials available, or system to disable them. Creator always means the task's createdBy actor, never the current requester. Only that original creator may enable creator mode. Omit or use null to leave unchanged.").optional()
+			credentialMode: z.enum(["system", "creator"]).nullable().describe("Set creator to make the task's original creator credentials available, or system to disable them. Creator always means the task's createdBy actor, never the current requester. Only that original creator may enable creator mode. Omit or use null to leave unchanged.").optional(),
+			status: z.enum(["active", "paused"]).nullable().describe("Set active to resume a paused or blocked automation, or paused to stop it. Only the creator can change the status. Omit or use null to leave unchanged.").optional()
 		}).strict(),
 		prepareArguments(args) {
-			const { credentialMode, outcomes, instruction, trigger, ...prepared } = args;
+			const { credentialMode, outcomes, instruction, trigger, status, ...prepared } = args;
 			return {
 				...prepared,
 				...instruction != null ? { instruction } : void 0,
 				...trigger != null ? { trigger } : void 0,
 				...outcomes != null ? { outcomes } : void 0,
-				...credentialMode != null ? { credentialMode } : void 0
+				...credentialMode != null ? { credentialMode } : void 0,
+				...status != null ? { status } : void 0
 			};
 		},
 		outputSchema: eventAutomationToolResultSchema,
@@ -11196,21 +10566,28 @@ function createUpdateEventAutomationTool(context, catalog) {
 			const current = await writableEventAutomation(context, input.automationId);
 			const { actor } = requireEventAutomationSlackContext(context);
 			const isCreator = actor.userId === current.createdBy.slackUserId;
-			if (input.title === void 0 && input.instruction === void 0 && input.trigger === void 0 && input.outcomes == null && input.credentialMode == null) throw new ToolInputError("Event automation update requires a change.");
+			const edits = input.title !== void 0 || input.instruction !== void 0 || input.trigger !== void 0 || input.outcomes != null || input.credentialMode != null;
+			if (!edits && input.status == null) throw new ToolInputError("Event automation update requires a change.");
+			if (input.status != null && !isCreator) throw new ToolInputError("Only the creator of this event automation can pause or resume it.");
 			if (input.instruction != null && input.instruction !== current.task.text) requireRequesterMention(input.instruction, actor);
-			const next = await editEventAutomation(current, {
-				title: input.title,
-				instruction: input.instruction ?? void 0,
-				trigger: input.trigger ?? void 0,
-				outcomes: input.outcomes ?? void 0,
-				credentialMode: input.credentialMode ?? void 0
-			}, isCreator, catalog);
-			const saved = await saveEventAutomation(getDb(), next, automationRevision(current), {
-				slackUserId: actor.userId,
-				...actor.fullName ? { fullName: actor.fullName } : void 0,
-				...actor.userName ? { userName: actor.userName } : void 0
-			});
-			if (!saved) throw new ToolInputError("Event automation was not found.");
+			let saved = current;
+			if (edits) {
+				const next = await editEventAutomation(current, {
+					title: input.title,
+					instruction: input.instruction ?? void 0,
+					trigger: input.trigger ?? void 0,
+					outcomes: input.outcomes ?? void 0,
+					credentialMode: input.credentialMode ?? void 0
+				}, isCreator, catalog);
+				const edited = await saveEventAutomation(getDb(), next, automationRevision(current), {
+					slackUserId: actor.userId,
+					...actor.fullName ? { fullName: actor.fullName } : void 0,
+					...actor.userName ? { userName: actor.userName } : void 0
+				});
+				if (!edited) throw new ToolInputError("Event automation was not found.");
+				saved = edited;
+			}
+			if (input.status != null) saved = await setEventAutomationStatus(getDb(), saved.id, input.status, automationRevision(saved));
 			return eventAutomationToolResult(context.conversationId, saved, catalog, actor.userId);
 		}
 	});
@@ -11228,193 +10605,6 @@ function createEventAutomationTools(context, catalog) {
 	};
 }
 //#endregion
-//#region src/chat/scheduled-automations/tasks.ts
-const SCHEDULER_KEY_PREFIX = "junior:scheduler";
-const retainedScheduledAutomationSchema = scheduledAutomationSchema.omit({
-	creatorIdentityId: true,
-	title: true
-}).extend({
-	destination: slackDestinationSchema,
-	outcomes: z.array(taskOutcomeSchema).max(5),
-	version: z.number().optional()
-}).strict();
-/** Decode a retained scheduler task row and reject invalid routing context. */
-function parseScheduledAutomationRow(row) {
-	const record = z.record(z.string(), z.unknown()).safeParse(row.record);
-	if (!record.success) return void 0;
-	const { creatorIdentityId: legacyCreatorIdentityId, title: legacyTitle, ...retained } = record.data;
-	const current = retained.outcomes === void 0 && retained.destination !== void 0 ? {
-		...retained,
-		outcomes: [{
-			action: "send_message",
-			destination: retained.destination
-		}]
-	} : retained;
-	const parsed = retainedScheduledAutomationSchema.safeParse(current);
-	if (!parsed.success) return void 0;
-	const { status, version: _version, ...retainedTask } = parsed.data;
-	const destination = {
-		platform: "slack",
-		teamId: retainedTask.destination.teamId,
-		channelId: retainedTask.destination.channelId
-	};
-	const task = {
-		...retainedTask,
-		destination,
-		outcomes: retainedTask.outcomes.map((outcome) => ({
-			...outcome,
-			destination: {
-				platform: "slack",
-				teamId: outcome.destination.teamId,
-				channelId: outcome.destination.channelId
-			}
-		}))
-	};
-	const fallbackIdentity = row.creatorIdentityId === null ? z.string().safeParse(legacyCreatorIdentityId) : void 0;
-	const creatorIdentityId = row.creatorIdentityId ?? (fallbackIdentity?.success ? fallbackIdentity.data : void 0);
-	if (creatorIdentityId === void 0) return void 0;
-	const fallbackTitle = row.title === null ? z.string().safeParse(legacyTitle) : void 0;
-	const title = (row.title !== null ? row.title : fallbackTitle?.success ? fallbackTitle.data : void 0)?.trim() || void 0;
-	return {
-		...task,
-		creatorIdentityId,
-		status,
-		...title ? { title } : void 0
-	};
-}
-/** Keep scan paths from returning current or legacy tombstones. */
-function isListedScheduledAutomation(task) {
-	return task !== void 0 && task.status !== "deleted";
-}
-/** Build the stable run id for one task occurrence. */
-function scheduledRunId(taskId, scheduledForMs) {
-	return `${taskId}:${scheduledForMs}`;
-}
-/** Acquire the deployed advisory lock for one scheduled automation. */
-function withScheduledAutomationLock(db, taskId, callback) {
-	return db.transaction(async (tx) => {
-		await tx.execute(sql`SELECT pg_advisory_xact_lock(hashtext(${`${SCHEDULER_KEY_PREFIX}:task:${taskId}:lock`}))`);
-		return await callback(tx);
-	});
-}
-function requireStoredTask(task) {
-	const parsed = scheduledAutomationSchema.safeParse(task);
-	if (!parsed.success) throw new Error("Scheduled automation routing context is invalid.");
-	const { title, ...current } = parsed.data;
-	const normalizedTitle = title?.trim() || void 0;
-	return {
-		...current,
-		...normalizedTitle ? { title: normalizedTitle } : void 0
-	};
-}
-function scheduledAutomationJsonRecord(task) {
-	const { title: _title, ...record } = task;
-	return record;
-}
-async function upsertScheduledAutomation(db, task) {
-	const title = task.title?.trim() || null;
-	await db.insert(juniorSchedulerTasks).values({
-		createdAtMs: task.createdAtMs,
-		creatorIdentityId: task.creatorIdentityId,
-		creatorSlackUserId: task.createdBy.slackUserId,
-		id: task.id,
-		nextRunAtMs: task.nextRunAtMs,
-		record: scheduledAutomationJsonRecord(task),
-		runNowAtMs: task.runNowAtMs,
-		status: task.status,
-		teamId: task.destination.teamId,
-		title
-	}).onConflictDoUpdate({
-		target: juniorSchedulerTasks.id,
-		set: {
-			createdAtMs: sql`excluded.created_at_ms`,
-			creatorIdentityId: sql`excluded.creator_identity_id`,
-			creatorSlackUserId: sql`excluded.creator_slack_user_id`,
-			nextRunAtMs: sql`excluded.next_run_at_ms`,
-			record: sql`excluded.record`,
-			runNowAtMs: sql`excluded.run_now_at_ms`,
-			status: sql`excluded.status`,
-			teamId: sql`excluded.team_id`,
-			title: sql`excluded.title`
-		}
-	});
-}
-/** Read and decode one scheduled automation. */
-async function readScheduledAutomation(db, taskId) {
-	const rows = await db.select({
-		creatorIdentityId: juniorSchedulerTasks.creatorIdentityId,
-		record: juniorSchedulerTasks.record,
-		title: juniorSchedulerTasks.title
-	}).from(juniorSchedulerTasks).where(eq(juniorSchedulerTasks.id, taskId)).limit(1);
-	return rows[0] ? parseScheduledAutomationRow(rows[0]) : void 0;
-}
-async function readListedScheduledAutomations(db, teamId) {
-	return (await db.select({
-		creatorIdentityId: juniorSchedulerTasks.creatorIdentityId,
-		record: juniorSchedulerTasks.record,
-		title: juniorSchedulerTasks.title
-	}).from(juniorSchedulerTasks).where(and(notInArray(juniorSchedulerTasks.status, ["deleted"]), teamId === void 0 ? void 0 : eq(juniorSchedulerTasks.teamId, teamId))).orderBy(asc(juniorSchedulerTasks.createdAtMs), asc(juniorSchedulerTasks.id))).map(parseScheduledAutomationRow).filter(isListedScheduledAutomation);
-}
-/** List decoded scheduled automations in stable creation order. */
-async function listScheduledAutomations(db) {
-	return await readListedScheduledAutomations(db);
-}
-/** List decoded scheduled automations for one team in stable creation order. */
-async function listScheduledAutomationsForTeam(db, teamId) {
-	return await readListedScheduledAutomations(db, teamId);
-}
-async function writeScheduledAutomation(db, task, current, editedBy) {
-	if (current?.status === "blocked" && task.status === "active" && typeof task.nextRunAtMs === "number" && Number.isFinite(task.nextRunAtMs)) await db.delete(juniorSchedulerRuns).where(and(eq(juniorSchedulerRuns.id, scheduledRunId(task.id, task.nextRunAtMs)), eq(juniorSchedulerRuns.status, "blocked")));
-	if (task.status === "deleted" && current?.status !== "deleted") await skipPendingRunsForDeletedTask(db, task);
-	await upsertScheduledAutomation(db, task);
-	await recordAutomationVersion(db, "scheduled", task, current, editedBy);
-}
-async function skipPendingRunsForDeletedTask(db, task) {
-	const errorMessage = `Scheduled automation ${task.id} was deleted before the run started.`;
-	const rows = await db.select({ record: juniorSchedulerRuns.record }).from(juniorSchedulerRuns).where(and(eq(juniorSchedulerRuns.taskId, task.id), eq(juniorSchedulerRuns.status, "pending")));
-	for (const row of rows) {
-		const parsed = scheduledRunSchema.safeParse(row.record);
-		if (!parsed.success || parsed.data.status !== "pending") continue;
-		const next = scheduledRunSchema.parse({
-			...parsed.data,
-			completedAtMs: task.updatedAtMs,
-			errorMessage,
-			status: "skipped"
-		});
-		await db.update(juniorSchedulerRuns).set({
-			record: next,
-			status: next.status
-		}).where(and(eq(juniorSchedulerRuns.id, next.id), eq(juniorSchedulerRuns.status, "pending")));
-	}
-}
-/** Create a scheduled automation once under its retry-stable task lock. */
-async function createScheduledAutomation(db, task) {
-	const next = requireStoredTask(task);
-	return await withScheduledAutomationLock(db, task.id, async (tx) => {
-		const current = await readScheduledAutomation(tx, task.id);
-		if (current) return current;
-		await writeScheduledAutomation(tx, next, void 0);
-		return next;
-	});
-}
-/**
-* Save a scheduled automation and clear its blocked occurrence on reactivation.
-* Pass `editedBy` when a person changes the definition so its version names them.
-*/
-async function saveScheduledAutomation(db, task, expectedRevision, editedBy) {
-	const next = requireStoredTask(task);
-	await withScheduledAutomationLock(db, task.id, async (tx) => {
-		const current = await readScheduledAutomation(tx, task.id);
-		if (expectedRevision !== void 0) requireAutomationRevision(current, expectedRevision);
-		await writeScheduledAutomation(tx, next, current, editedBy);
-	});
-	return next;
-}
-/** Save a scheduled automation inside a task lock already held by the caller. */
-async function saveScheduledAutomationInLock(db, task, current) {
-	await writeScheduledAutomation(db, requireStoredTask(task), current);
-}
-//#endregion
 //#region src/chat/scheduled-automations/telemetry.ts
 /** Safe structured telemetry attributes for scheduled-automation lifecycle events. */
 /** Correlation attributes shared by scheduled-automation create and run events. */
@@ -11451,76 +10641,6 @@ function logScheduledAutomationRunSkipped(task, run, extras = {}) {
 	logInfo("scheduled_automation.run.skipped", scheduledAutomationRunAttributes(task, run, extras));
 }
 //#endregion
-//#region src/chat/slack/user.ts
-const slackUserInfoSchema = z.object({
-	ok: z.literal(true),
-	user: z.object({
-		name: z.string().nullish(),
-		tz: z.string().nullish(),
-		profile: z.object({
-			email: z.string().nullish(),
-			real_name: z.string().nullish()
-		}).optional()
-	})
-});
-const USER_CACHE_TTL_MS = 3e5;
-const userCache = /* @__PURE__ */ new Map();
-function userCacheKey(teamId, userId) {
-	return `${teamId}:${userId}`;
-}
-function readFromCache(teamId, userId) {
-	const hit = userCache.get(userCacheKey(teamId, userId));
-	if (!hit) return null;
-	if (hit.expiresAt < Date.now()) {
-		userCache.delete(userCacheKey(teamId, userId));
-		return null;
-	}
-	return hit.value;
-}
-function writeToCache(teamId, userId, value) {
-	userCache.set(userCacheKey(teamId, userId), {
-		value,
-		expiresAt: Date.now() + USER_CACHE_TTL_MS
-	});
-}
-/** Fetch Slack user profile info with in-memory TTL cache to avoid repeated API calls. */
-async function lookupSlackUser(teamId, userId) {
-	if (!teamId || !userId) return null;
-	const cached = readFromCache(teamId, userId);
-	if (cached) return cached;
-	const token = getSlackBotToken();
-	if (!token) return null;
-	try {
-		const response = await fetch(`https://slack.com/api/users.info?user=${encodeURIComponent(userId)}`, { headers: { authorization: `Bearer ${token}` } });
-		if (!response.ok) {
-			logWarn("slack.user.lookup.failed", {
-				"enduser.id": userId,
-				"app.slack.team_id": teamId,
-				"http.response.status_code": response.status
-			});
-			return null;
-		}
-		const parsed = slackUserInfoSchema.safeParse(await response.json());
-		if (!parsed.success) return null;
-		const payload = parsed.data;
-		const result = {
-			userName: payload.user.name?.trim() || void 0,
-			fullName: payload.user.profile?.real_name?.trim() || void 0,
-			email: payload.user.profile?.email?.trim() || void 0,
-			timezone: payload.user.tz?.trim() || void 0
-		};
-		writeToCache(teamId, userId, result);
-		return result;
-	} catch (error) {
-		logWarn("slack.user.lookup.failed", {
-			"enduser.id": userId,
-			"app.slack.team_id": teamId,
-			"exception.message": error instanceof Error ? error.message : String(error)
-		});
-		return null;
-	}
-}
-//#endregion
 //#region src/chat/scheduled-automations/identity.ts
 const SLACK_USER_ID_PATTERN = /^[UW][A-Z0-9]{5,}$/;
 function clean(value) {
@@ -11551,7 +10671,6 @@ function sanitizeScheduledAutomationPrincipal(principal) {
 //#endregion
 //#region src/chat/scheduled-automations/tool-support.ts
 const TASK_ID_PREFIX = "sched";
-const DEFAULT_SCHEDULE_TIMEZONE = "America/Los_Angeles";
 const compactTaskResultSchema = z.object({
 	id: z.string(),
 	title: z.string().nullable(),
@@ -11768,23 +10887,6 @@ function buildTaskId(args) {
 function normalizeStatus(value) {
 	if (value === "active" || value === "blocked") return value;
 }
-/** Centralize scheduler timezone defaulting for all concrete tool entry points. */
-function getDefaultScheduleTimezone() {
-	return process.env.JUNIOR_TIMEZONE?.trim() || DEFAULT_SCHEDULE_TIMEZONE;
-}
-/**
-* Pick the timezone for a new schedule when the user names none: the
-* creator's Slack profile, then the saved user timezone, then the install
-* default. A valid Slack timezone is saved on the linked user.
-*/
-async function resolveCreatorScheduleTimezone(args) {
-	const timezone = (await lookupSlackUser(args.teamId, args.slackUserId))?.timezone;
-	if (timezone && isValidTimeZone$1(timezone)) {
-		if (args.userId) await saveUserTimezone(args.db, args.userId, timezone, args.nowMs);
-		return timezone;
-	}
-	return (args.userId ? await readUserTimezone(args.db, args.userId) : void 0) ?? getDefaultScheduleTimezone();
-}
 //#endregion
 //#region src/chat/scheduled-automations/tools/create.ts
 /** Create a tool that stores a scheduled automation for the active Slack context. */
@@ -11832,11 +10934,13 @@ function createSlackScheduleCreateAutomationTool(context) {
 			const identity = creator?.identity;
 			if (!identity || identity.provider !== "slack" || identity.providerTenantId !== destination.teamId || identity.providerSubjectId !== actor.slackUserId) throwToolInputError("Scheduled automation creator identity is unavailable.");
 			const nowMs = context.now?.() ?? Date.now();
-			const defaultTimezone = input.schedule.timezone ?? await resolveCreatorScheduleTimezone({
+			const defaultTimezone = input.schedule.timezone ?? await resolveUserTimezone({
 				db,
 				nowMs,
-				slackUserId: actor.slackUserId,
-				teamId: destination.teamId,
+				slack: {
+					teamId: destination.teamId,
+					userId: actor.slackUserId
+				},
 				...creator.user ? { userId: creator.user.id } : void 0
 			});
 			let compiled;
@@ -11857,7 +10961,7 @@ function createSlackScheduleCreateAutomationTool(context) {
 				instruction: input.instruction,
 				title: input.title
 			});
-			const committed = await createScheduledAutomation(db, {
+			const task = {
 				id,
 				createdAtMs: nowMs,
 				updatedAtMs: nowMs,
@@ -11874,7 +10978,8 @@ function createSlackScheduleCreateAutomationTool(context) {
 				outcomes: await resolveTaskOutcomes(input.outcomes, destination, actor.slackUserId),
 				task: { text: input.instruction },
 				...title ? { title } : void 0
-			});
+			};
+			const committed = await createScheduledAutomation(db, task);
 			if (!sameDestination(committed, destination) || committed.createdBy.slackUserId !== actor.slackUserId) throwToolInputError("Scheduled automation operation identity is invalid.");
 			logInfo("scheduled_automation.create.completed", scheduledAutomationAttributes(committed));
 			return scheduleAutomationToolResult(context.conversationId, committed, actor.slackUserId);
@@ -12056,7 +11161,7 @@ async function editScheduledAutomation(current, input, isCreator, nowMs) {
 	let compiled;
 	if (input.schedule !== void 0) try {
 		compiled = compileScheduleIntent({
-			defaultTimezone: current.schedule.timezone || getDefaultScheduleTimezone(),
+			defaultTimezone: current.schedule.timezone || defaultTimezone(),
 			intent: input.schedule,
 			nowMs
 		});
@@ -15121,7 +14226,7 @@ async function resolveStoredProvider(teamId, provider, query) {
 /** Create the tool that resolves people by identity provider and query. */
 function createUserLookupTool(teamId, providers) {
 	return zodTool({
-		description: "Look up people by identity provider and query. Pass an enabled `provider` and its provider subject ID or handle. The `slack` provider also accepts email and name searches. Returns Slack `mention` values (`<@U…>`) for the current workspace. Use a mention only when one person clearly matches; otherwise ask which person the user means.",
+		description: "Look up people by identity provider and query. Pass an enabled `provider` and its provider subject ID or handle. For `slack`, pass the person's Slack user ID (`U…`) whenever the conversation shows one, such as the requester's `author_id`, a participant's `actor_id`, or a `<@U…>` mention. The `slack` provider also accepts email and name searches. Use name search only for people with no known ID, because it can miss people in large workspaces. Returns Slack `mention` values (`<@U…>`) for the current workspace. Use a mention only when one person clearly matches; otherwise ask which person the user means.",
 		annotations: {
 			destructiveHint: false,
 			idempotentHint: true,
@@ -15130,7 +14235,7 @@ function createUserLookupTool(teamId, providers) {
 		},
 		inputSchema: z.object({
 			provider: z.enum(providers).describe("Enabled identity provider to query."),
-			query: z.string().trim().min(1).describe("Provider subject ID, handle, Slack email, or Slack name.")
+			query: z.string().trim().min(1).describe("Provider subject ID, handle, Slack email, or Slack name. Prefer a Slack user ID (U…) when one is known.")
 		}).strict(),
 		outputSchema: juniorToolOutputSchema,
 		execute: async ({ provider, query }) => {
@@ -15213,14 +14318,6 @@ function createSystemTimeTool() {
 		}
 	});
 }
-function isValidTimeZone(timezone) {
-	try {
-		new Intl.DateTimeFormat("en-US", { timeZone: timezone }).format();
-		return true;
-	} catch {
-		return false;
-	}
-}
 function getTimeZoneOffsetMinutes(timestampMs, timezone) {
 	const parts = getZonedDateTimeParts(timestampMs, timezone);
 	const asUtcMs = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
@@ -17032,6 +16129,7 @@ function createTools(availableSkills, hooks = {}, context, options = {}) {
 	}
 	if (context.handoff) tools.handoff = createHandoffTool(context.handoff);
 	if (context.spawnAgent) tools.spawnAgent = createSpawnAgentTool(context.spawnAgent);
+	if (context.automation) tools[FINISH_AUTOMATION_RUN_TOOL_NAME] = createFinishAutomationRunTool(context.automation);
 	if (context.mcpToolManager) {
 		tools.searchMcpTools = createSearchMcpToolsTool(context.mcpToolManager);
 		tools.callMcpTool = createCallMcpToolTool(context.mcpToolManager);
@@ -19074,6 +18172,22 @@ async function requestBodyBytes(request) {
 	if (request.method === "GET" || request.method === "HEAD" || request.body === null) return;
 	return await request.arrayBuffer();
 }
+/**
+* Explain a request body that the runtime delivered already used.
+*
+* The forwarded headers cannot show whether the body was empty, so the proxy
+* does not send a credentialed write upstream without its payload.
+*/
+function unreadableBodyResponse(eventId) {
+	return Response.json({
+		source: "junior-egress",
+		error: "Junior's sandbox egress proxy could not read the request body, so it did not send the request upstream.",
+		...eventId ? { sentryEventId: eventId } : void 0
+	}, {
+		status: 500,
+		headers: { "cache-control": "no-store" }
+	});
+}
 /** Identify GitHub writes whose body determines whether a grant is safe. */
 function githubBodyInspection(input) {
 	if (input.provider !== "github" || input.requestMethod.toUpperCase() !== "POST" || input.upstreamUrl.hostname.toLowerCase() !== "api.github.com") return;
@@ -19229,11 +18343,28 @@ async function recordSandboxPermissionDenied(input) {
 */
 async function executeCredentialedEgressRequest(input) {
 	const { activeEgressId, credentialContext, deps, operation, provider, request, upstreamUrl } = input;
+	let body;
+	try {
+		body = await requestBodyBytes(request);
+	} catch (error) {
+		if (!(error instanceof TypeError)) throw error;
+		return unreadableBodyResponse(logException(error, "sandbox.egress.request_body.unreadable", {
+			...egressAttributes({
+				egressId: activeEgressId,
+				host: upstreamUrl.hostname,
+				method: request.method,
+				path: upstreamUrl.pathname,
+				provider,
+				status: 500
+			}),
+			...routingAttributes(request, upstreamUrl)
+		}));
+	}
 	const bodyForGrantSelection = githubBodyInspection({
 		provider,
 		requestMethod: request.method,
 		upstreamUrl
-	}) ? await requestBodyBytes(request) : void 0;
+	}) ? body : void 0;
 	let grantSelection;
 	try {
 		grantSelection = await selectSandboxEgressGrant({
@@ -19325,7 +18456,6 @@ async function executeCredentialedEgressRequest(input) {
 		return Response.json({ error: "Credential lease does not cover forwarded host" }, { status: 403 });
 	}
 	const fetchImpl = deps.fetch ?? fetch;
-	const body = bodyForGrantSelection ?? await requestBodyBytes(request);
 	let retriedAfter403 = false;
 	while (true) {
 		const headers = requestHeaders(request, lease, upstreamUrl.hostname, deps.tracePropagation ?? {});
@@ -19955,7 +19085,8 @@ async function wireAgentTools(args) {
 		surface: args.surface,
 		...args.currentActor ? { resolveActorIdentity: async () => await readActorIdentity(args.currentActor) } : void 0,
 		...args.durability.spawnAgent ? { spawnAgent: args.durability.spawnAgent } : void 0,
-		...args.requestHandoff ? { handoff: args.requestHandoff } : void 0
+		...args.requestHandoff ? { handoff: args.requestHandoff } : void 0,
+		...args.run.dispatch?.declaresResult ? { automation: { sendsMessage: args.run.dispatch.outcomes?.length !== 0 } } : void 0
 	};
 	const toolRoute = resolveToolRuntimeRoute({
 		actor: args.currentActor,
@@ -20788,7 +19919,11 @@ async function compactActiveContextIfNeeded(args, deps) {
 //#endregion
 //#region src/chat/agent/handoff.ts
 /** Tools that must be the only tool call in their assistant message. */
-const EXCLUSIVE_TOOL_NAMES = [HANDOFF_TOOL_NAME, "switchWorkspace"];
+const EXCLUSIVE_TOOL_NAMES = [
+	HANDOFF_TOOL_NAME,
+	"switchWorkspace",
+	FINISH_AUTOMATION_RUN_TOOL_NAME
+];
 /** Return the exclusive tool name when one is present among the calls. */
 function exclusiveToolName(toolCalls) {
 	for (const name of EXCLUSIVE_TOOL_NAMES) if (toolCalls.some((call) => call.name === name)) return name;
@@ -20987,6 +20122,7 @@ async function executeAgentRunInPrivacyContext(run, conversationPrivacy, runLogC
 	const conversationId = run.conversationId;
 	const turnId = run.turnId;
 	const runId = run.runId;
+	const requireAutomationResult = run.dispatch?.declaresResult === true;
 	const input = {
 		actor: run.instruction.actor,
 		includeConversationContextWithPiMessages: run.instruction.includeConversationContextWithHistory,
@@ -21511,11 +20647,13 @@ async function executeAgentRunInPrivacyContext(run, conversationPrivacy, runLogC
 					};
 				}
 			},
-			afterToolCall: async ({ result, toolCall }, signal) => {
+			afterToolCall: async ({ isError, result, toolCall }, signal) => {
 				const timedOutResult = runResume.timedOut && signal?.aborted ? projectTimedOutToolResult(result) : void 0;
 				const sourceResult = timedOutResult ?? result;
 				const projectedResult = wiring.projectActionReviewResult(toolCall.id, sourceResult);
-				return timedOutResult || projectedResult !== result ? projectedResult : void 0;
+				const override = timedOutResult || projectedResult !== result ? projectedResult : void 0;
+				if (toolCall.name === "finishAutomationRun" && !isError && !override) return { terminate: true };
+				return override;
 			},
 			prepareNextTurnWithContext: async (nextTurn, hookSignal) => {
 				try {
@@ -21564,6 +20702,7 @@ async function executeAgentRunInPrivacyContext(run, conversationPrivacy, runLogC
 			runResume.setBeforeMessageCount(agent.state.messages.length);
 			if (shouldPromptAgent) runResume.setTurnStartMessageIndex(agent.state.messages.length);
 			const authPauseOutcome = await withSpan(`invoke_agent ${botConfig.userName}`, "gen_ai.invoke_agent", spanContext, async () => {
+				if (requireAutomationResult && readAutomationResult(agent.state.messages)) return;
 				const promptTimestamp = restoredPromptTimestamp ?? Date.now();
 				const contextMessage = shouldPromptAgent && promptContextContentParts.length > 0 ? {
 					role: "user",
@@ -21681,6 +20820,7 @@ async function executeAgentRunInPrivacyContext(run, conversationPrivacy, runLogC
 				run = shouldPromptAgent && !capacityUpdate ? agent.prompt(freshPromptMessage) : agent.continue();
 				let discardedRetryUsage;
 				let actionConfirmationRetryUsed = false;
+				let automationResultReminderUsed = !requireAutomationResult;
 				let providerRetryAttempt = 0;
 				let emptyOutputAttempt = 0;
 				const prepareRetry = async (messages) => {
@@ -21720,6 +20860,15 @@ async function executeAgentRunInPrivacyContext(run, conversationPrivacy, runLogC
 							run = agent.continue();
 							continue;
 						}
+						const automationResultReminder = automationResultReminderUsed ? void 0 : remindMissingAutomationResult(agent.state.messages);
+						if (automationResultReminder) {
+							automationResultReminderUsed = true;
+							agent.state.messages = automationResultReminder;
+							await runResume.persistSafeBoundary(automationResultReminder);
+							logWarn("agent.turn.automation_result.reminded", {});
+							run = agent.continue();
+							continue;
+						}
 						const emptyOutputContinuation = nextEmptyOutputContinuation({
 							attempt: emptyOutputAttempt,
 							lastAssistant,
@@ -21786,7 +20935,8 @@ async function executeAgentRunInPrivacyContext(run, conversationPrivacy, runLogC
 				usage: turnUsage,
 				executionProfile: turnRoute,
 				assistantUserName: botConfig.userName,
-				modelId: activeModelId
+				modelId: activeModelId,
+				requireAutomationResult
 			})
 		};
 	} catch (error) {
@@ -21879,7 +21029,7 @@ function createAgentRunner(execute, options) {
 			} } : void 0
 		};
 		if (run.instruction.storedAttachments?.length) {
-			const { loadInputImages } = await import("./images-C_0iwPsW.js").then((n) => n.n);
+			const { loadInputImages } = await import("./images-DY6Pxq4w.js").then((n) => n.n);
 			const storage = nextRun.environment?.attachmentStorage;
 			if (!storage) throw new Error("Attachment storage is unavailable.");
 			nextRun.instruction = {
@@ -21895,4 +21045,4 @@ function createAgentRunner(execute, options) {
 	} };
 }
 //#endregion
-export { eventAutomationBelongsToUser as $, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS as $t, resolveSlackChannelIdFromMessage as A, slackEntitySchema as An, beginConversationResume as At, parseScheduledAutomationRow as B, setConfigDefaults as Bn, ensureConversationWake as Bt, renderBlockText as C, normalizeSlackReplyMarkdown as Cn, timerWatchCredentialSubject as Ct, storeAttachment as D, addReactionToMessage as Dn, ackMessages as Dt, requestAttachmentDeletion as E, truncateStatusText as En, pluginEventCatalog as Et, lookupSlackUser as F, actorFromRun as Fn, completeConversationStop as Ft, withScheduledAutomationLock as G, recordAttemptFailure as Gt, saveScheduledAutomation as H, getConversationWorkState as Ht, logScheduledAutomationRunSkipped as I, toolInvocationDestination as In, completeConversationWork as It, eventAutomationTriggerAvailable as J, removeActiveConversation as Jt, editEventAutomation as K, recordConversationRetry as Kt, scheduledAutomationRunAttributes as L, AuthorizationFlowDisabledError as Ln, countPendingConversationMessages as Lt, getConversationInfo as M, createUserTokenStore as Mn, checkInConversationWork as Mt, listThreadReplies as N, buildSteeringPiMessage as Nn, clearConsumedConversationWake as Nt, parseSlackThreadId as O, postSlackMessage as On, appendAndEnqueueExclusiveInboundMessage as Ot, editScheduledAutomation as P, RetryableDeliveryError as Pn, clearExpiredConversationLease as Pt, deleteEventAutomation as Q, stopConversationWork as Qt, listScheduledAutomations as R, shouldEmitDevAgentTrace as Rn, deadLetterAttempt as Rt, renderAttachmentText as S, formatSlackLink as Sn, isEventMailboxMetadata as St, readLiveAttachment as T, slackMention as Tn, eventGuidance as Tt, saveScheduledAutomationInLock as U, hasRunnableConversationWork as Ut, readScheduledAutomation as V, getConversation as Vt, scheduledRunId as W, listActiveConversationIds as Wt, resolveTaskOutcomes as X, requestConversationWork as Xt, effectiveTaskOutcomes as Y, requestAnotherSlice as Yt, collectEventAutomationMatchKeys as Z, startConversationWork as Zt, resolvePluginOAuthAccount as _, formatProviderLabel as _n, AgentInvocationLimitError as _t, buildAuthPauseResponse as a, renderTaskInput as an, setEventAutomationStatus as at, unpublishedArtifactHeaders as b, startOAuthFlow as bn, ingestEvent as bt, deleteMcpAuthSessionsForUserProvider as c, resolveSandboxEgressProviderForHost as cn, readAutomationVersion as ct, getMcpAuthSession as d, SANDBOX_EGRESS_PROXY_PATH as dn, automationRevision as dt, CONVERSATION_WORK_STALE_ENQUEUE_MS as en, findMatchingEventAutomations as et, getMcpStoredOAuthCredentials as f, clearSandboxEgressSignals as fn, requireAutomationRevision as ft, readStats as g, sandboxEgressSignalsResponseSchema as gn, AgentInvocationBusyError as gt, latestProgressStatus as h, parseSandboxEgressCredentialToken as hn, createAgentInvocationSchema as ht, executeCredentialedEgressRequest as i, isInvalidConversationRecordError as in, saveEventAutomation as it, resolveSlackChannelIdFromThreadId as j, slackExternalRefIdSchema as jn, cancelHumanFacingPendingMessages as jt, readSlackRawMessageContext as k, removeReactionFromMessage as kn, appendAndEnqueueInboundMessage as kt, deleteMcpServerSessionId as l, normalizeSandboxEgressTracePropagationDomains as ln, sameDefinitionValue as lt, PluginCredentialFailureError as m, consumeSandboxEgressPermissionDeniedSignal as mn, agentInvocationSchema as mt, executeAgentRun as n, hasRunnableConversationWork$1 as nn, listDeletedEventAutomationsCreatedBy as nt, finalizeMcpAuthorization as o, maybePostAutomatedTurnLimitNotice as on, automationDefinition as ot, putMcpStoredOAuthCredentials as p, consumeSandboxEgressAuthRequiredSignal as pn, agentBindingSchema as pt, AutomationEditError as q, releaseConversationWork as qt, createContextCompactor as r, isFinalAttempt as rn, parseEventAutomationRow as rt, deleteMcpAuthSession as s, recordFinishedTurnForAutomatedLimit as sn, listAutomationVersions as st, createAgentRunner as t, hasConversationStop as tn, getEventAutomation as tt, deleteMcpStoredOAuthCredentials as u, shouldPropagateSandboxEgressTrace as un, AutomationConflictError as ut, publicArtifactHeaders as v, parseOAuthStatePayload as vn, getMcpProviderErrorAttributes as vt, collectAttachmentGarbage as w, normalizeSlackStatusText as wn, getEventCatalog as wt, lookupSlackUserProfile as x, escapeSlackMrkdwnText as xn, EVENT_WAIT_MS as xt, readPublicArtifact as y, resolveBaseUrl as yn, processWorkspaceSnapshotJob as yt, listScheduledAutomationsForTeam as z, getConfigDefaults as zn, drainConversationMailbox as zt };
+export { getEventCatalog as $, actorFromRun as $t, resolveSlackChannelIdFromMessage as A, hasConversationStop as At, effectiveTaskOutcomes as B, SANDBOX_EGRESS_PROXY_PATH as Bt, renderBlockText as C, removeActiveConversation as Ct, storeAttachment as D, stopConversationWork as Dt, requestAttachmentDeletion as E, startConversationWork as Et, logScheduledAutomationRunSkipped as F, maybePostAutomatedTurnLimitNotice as Ft, AgentInvocationBusyError as G, sandboxEgressSignalsResponseSchema as Gt, agentBindingSchema as H, consumeSandboxEgressAuthRequiredSignal as Ht, scheduledAutomationRunAttributes as I, recordFinishedTurnForAutomatedLimit as It, processWorkspaceSnapshotJob as J, resolveBaseUrl as Jt, AgentInvocationLimitError as K, formatProviderLabel as Kt, editEventAutomation as L, resolveSandboxEgressProviderForHost as Lt, getConversationInfo as M, isFinalAttempt as Mt, listThreadReplies as N, isInvalidConversationRecordError as Nt, parseSlackThreadId as O, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS as Ot, editScheduledAutomation as P, renderTaskInput as Pt, timerWatchCredentialSubject as Q, RetryableDeliveryError as Qt, AutomationEditError as R, normalizeSandboxEgressTracePropagationDomains as Rt, renderAttachmentText as S, releaseConversationWork as St, readLiveAttachment as T, requestConversationWork as Tt, agentInvocationSchema as U, consumeSandboxEgressPermissionDeniedSignal as Ut, resolveTaskOutcomes as V, clearSandboxEgressSignals as Vt, createAgentInvocationSchema as W, parseSandboxEgressCredentialToken as Wt, EVENT_WAIT_MS as X, createUserTokenStore as Xt, ingestEvent as Y, startOAuthFlow as Yt, isEventMailboxMetadata as Z, buildSteeringPiMessage as Zt, resolvePluginOAuthAccount as _, getConversationWorkState as _t, buildAuthPauseResponse as a, shouldEmitDevAgentTrace as an, beginConversationResume as at, unpublishedArtifactHeaders as b, recordAttemptFailure as bt, deleteMcpAuthSessionsForUserProvider as c, clearConsumedConversationWake as ct, getMcpAuthSession as d, completeConversationWork as dt, toolInvocationDestination as en, eventGuidance as et, getMcpStoredOAuthCredentials as f, countPendingConversationMessages as ft, readStats as g, getConversation as gt, latestProgressStatus as h, ensureConversationWake as ht, executeCredentialedEgressRequest as i, runDispatchOutcome as in, appendAndEnqueueInboundMessage as it, resolveSlackChannelIdFromThreadId as j, hasRunnableConversationWork$1 as jt, readSlackRawMessageContext as k, CONVERSATION_WORK_STALE_ENQUEUE_MS as kt, deleteMcpServerSessionId as l, clearExpiredConversationLease as lt, PluginCredentialFailureError as m, drainConversationMailbox as mt, executeAgentRun as n, deliversFinalText as nn, ackMessages as nt, finalizeMcpAuthorization as o, getConfigDefaults as on, cancelHumanFacingPendingMessages as ot, putMcpStoredOAuthCredentials as p, deadLetterAttempt as pt, getMcpProviderErrorAttributes as q, parseOAuthStatePayload as qt, createContextCompactor as r, finishedRunReply as rn, appendAndEnqueueExclusiveInboundMessage as rt, deleteMcpAuthSession as s, setConfigDefaults as sn, checkInConversationWork as st, createAgentRunner as t, AuthorizationFlowDisabledError as tn, pluginEventCatalog as tt, deleteMcpStoredOAuthCredentials as u, completeConversationStop as ut, publicArtifactHeaders as v, hasRunnableConversationWork as vt, collectAttachmentGarbage as w, requestAnotherSlice as wt, lookupSlackUserProfile as x, recordConversationRetry as xt, readPublicArtifact as y, listActiveConversationIds as yt, eventAutomationTriggerAvailable as z, shouldPropagateSandboxEgressTrace as zt };