@sentry/junior 0.222.0 → 0.224.0

package/dist/{agent-7kKtDe-6.js → agent-runner-9g6TQk9y.js}

@@ -1,28 +1,28 @@
-import { C as resolveGatewayCredential, S as getGatewayApiKey, _ as findProviderError, b as isProviderRetryError, c as COMPACTION_SUMMARY_PREFIX, d as isCompactionSummaryText, f as renderCurrentInstruction, g as createProviderError, h as ProviderError, i as completeText, l as MODEL_HANDOFF_SUMMARY_PREFIX, m as escapeXml, n as GEN_AI_SERVER_ADDRESS, o as resolveGatewayModel, p as unwrapCurrentInstruction, r as completeObject, s as ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX, t as GEN_AI_PROVIDER_NAME, u as hasCompactedConversationContext, v as getProviderErrorAttributes, x as MISSING_GATEWAY_CREDENTIALS_ERROR } from "./client-CcSboWx_.js";
-import { C as withSpan, F as isRecord$2, P as normalizeIdentityEmail, S as withLogContext, _ as setSpanAttributes, a as extractGenAiUsageSummary, b as summarizeMessageText, c as getTracePropagationHeaders, d as logInfo, f as logWarn, h as serializeGenAiAttribute, i as extractGenAiUsageAttributes, l as logError, p as normalizeGenAiFinishReason, s as getLogContextAttributesForSpan, u as logException, v as setSpanStatus, y as setTags } from "./logging-qmsMdU0y.js";
+import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.js";
+import { C as resolveGatewayCredential, S as getGatewayApiKey, _ as findProviderError, b as isProviderRetryError, c as COMPACTION_SUMMARY_PREFIX, d as isCompactionSummaryText, f as renderCurrentInstruction, g as createProviderError, h as ProviderError, i as completeText, l as MODEL_HANDOFF_SUMMARY_PREFIX, m as escapeXml, n as GEN_AI_SERVER_ADDRESS, o as resolveGatewayModel, p as unwrapCurrentInstruction, r as completeObject, s as ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX, t as GEN_AI_PROVIDER_NAME, u as hasCompactedConversationContext, v as getProviderErrorAttributes, x as MISSING_GATEWAY_CREDENTIALS_ERROR } from "./client-B27ufhzl.js";
+import { C as withSpan, F as isRecord$2, P as normalizeIdentityEmail, S as withLogContext, _ as setSpanAttributes, a as extractGenAiUsageSummary, b as summarizeMessageText, c as getTracePropagationHeaders, d as logInfo, f as logWarn, h as serializeGenAiAttribute, i as extractGenAiUsageAttributes, l as logError, p as normalizeGenAiFinishReason, s as getLogContextAttributesForSpan, u as logException, v as setSpanStatus, y as setTags } from "./logging-iY0ssa2q.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-BGjdDVWD.js";
-import { h as normalizeSlackEmojiName, n as botConfig } from "./config-CGYv-YPE.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-C-4JQzKD.js";
+import { h as normalizeSlackEmojiName, n as botConfig } from "./config-BAhl7-RC.js";
 import { a as modelIdForProfile, c as TURN_REASONING_LEVELS, i as formatModelProfiles, o as modelProfileSchema, r as formatModelProfile, s as profileConfig, t as ModelProfileNotConfiguredError } from "./model-profile-CZmVoGdX.js";
 import { _ as parseSlackMessageTs, g as parseSlackUserId, h as parseSlackTeamId, i as credentialUserSubjectId, l as isUserActor, m as parseSlackChannelReferenceId, n as credentialContextSchema, p as parseSlackChannelId, t as credentialContextForActor } from "./context-Bplcgypl.js";
-import { A as tryWorkspaceRepoCheckoutPath, B as downloadPrivateSlackFile, C as invalidateReadySnapshot, D as SANDBOX_RUNTIME, E as setWorkspaceSnapshotBuild, Gt as getDb, Ht as getConversationEventStore, J as withSlackRetries, K as normalizeSlackConversationId, Kt as getSqlExecutor, M as resolveChannelCapabilities, O as deleteWorkspaceSnapshotBuilders, Q as readActorIdentity, S as WorkspaceValidationError, T as setWorkspaceSnapshot, U as getSlackClient, Ut as getConversationMessageSearchStore, V as getFilePermalink, W as isConversationScopedChannel, Wt as getConversationStore, _ as deleteWorkspace, at as STOP_WATCHING_TOOL_NAME, b as listWorkspaces, bt as createPluginLogger, c as getPluginTools, dt as findMatchingWatches, en as addAgentTurnUsage, ft as listWatches, g as createWorkspace, ht as getDashboardTaskLink, in as hasAgentTurnUsage, it as RESOURCE_WATCH_TOOL_SOURCE, j as workspaceRepoCheckoutPath, k as getWorkspaceSnapshotBuilder, l as getPluginUserPromptContributions, lt as createWatch, mt as getDashboardConversationLink, nt as RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS, ot as cancelSubscriptions, pt as JUNIOR_THREAD_STATE_TTL_MS, r as createPluginHookRunner, s as getPluginSystemPromptContributions, st as cancelWatch, tt as getSlackToolContext, u as getPlugins, un as parseDestination, ut as deliverWatch, v as getWorkspace, w as loadSnapshotsForProfile, x as updateWorkspace, y as getWorkspaceByName, z as SlackActionError } from "./agent-hooks-DkriF84n.js";
+import { A as tryWorkspaceRepoCheckoutPath, B as downloadPrivateSlackFile, C as invalidateReadySnapshot, D as SANDBOX_RUNTIME, E as setWorkspaceSnapshotBuild, Ft as saveObjectAnnotations, G as isDmChannel$1, Gt as getConversationMessageSearchStore, It as createPluginAnnotations, J as withSlackRetries, Jt as getSqlExecutor, K as normalizeSlackConversationId, Kt as getConversationStore, M as resolveChannelCapabilities, O as deleteWorkspaceSnapshotBuilders, Q as readActorIdentity, S as WorkspaceValidationError, T as setWorkspaceSnapshot, U as getSlackClient, V as getFilePermalink, W as isConversationScopedChannel, Wt as getConversationEventStore, _ as deleteWorkspace, at as STOP_WATCHING_TOOL_NAME, b as listWorkspaces, bt as createPluginLogger, c as getPluginTools, dt as findMatchingWatches, fn as parseDestination, ft as listWatches, g as createWorkspace, ht as getDashboardTaskLink, it as RESOURCE_WATCH_TOOL_SOURCE, j as workspaceRepoCheckoutPath, k as getWorkspaceSnapshotBuilder, l as getPluginUserPromptContributions, lt as createWatch, mt as getDashboardConversationLink, n as applyPluginFormatMarkdown, nn as addAgentTurnUsage, nt as RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS, on as hasAgentTurnUsage, ot as cancelSubscriptions, pt as JUNIOR_THREAD_STATE_TTL_MS, qt as getDb, r as createPluginHookRunner, s as getPluginSystemPromptContributions, st as cancelWatch, tt as getSlackToolContext, u as getPlugins, ut as deliverWatch, v as getWorkspace, w as loadSnapshotsForProfile, x as updateWorkspace, y as getWorkspaceByName, z as SlackActionError } from "./agent-hooks-DNLBwmsh.js";
 import { n as juniorDestinations } from "./destinations-BeBiJeEM.js";
-import { D as juniorIdentities, E as juniorConversations, a as juniorSchedulerRuns, d as AGENT_INVOCATION_MAILBOX_STATUSES, g as juniorConversationBriefs, k as juniorArtifacts, w as juniorAttachments, x as juniorConversationAnnotations } from "./executor-BLBZ-UB8.js";
-import { F as conversationBriefSchema, G as contextProvenance, J as sameActorIdentity, K as instructionActors, L as KNOWN_CONVERSATION_EVENT_TYPES, N as briefLinkSchema, P as briefOutcomeStatusSchema, j as automationCardSchema, q as instructionProvenanceFor } from "./conversation-BBDt88di.js";
+import { D as juniorIdentities, E as juniorConversations, a as juniorSchedulerRuns, d as AGENT_INVOCATION_MAILBOX_STATUSES, g as juniorConversationBriefs, k as juniorArtifacts, w as juniorAttachments, x as juniorConversationAnnotations } from "./executor-BG2Armby.js";
+import { F as briefLinkSchema, I as briefOutcomeStatusSchema, J as instructionActors, L as conversationBriefSchema, X as sameActorIdentity, Y as instructionProvenanceFor, j as messageCardRefSchema, q as contextProvenance, z as KNOWN_CONVERSATION_EVENT_TYPES } from "./conversation-1HUoZr2l.js";
 import { a as listReferenceFiles, c as soulPathCandidates, l as worldPathCandidates } from "./package-discovery-7a9YqLhE.js";
-import { a as resolveAuthTokenPlaceholder, c as fetchWithBoundedOAuthErrorBodies, d as CredentialUnavailableError, i as resolvePluginHeaderEnvRefs, l as getOAuthProviderErrorAttributes, o as resolvePluginCommandEnv, s as OAuthProviderError } from "./registry-DGyQCsiy.js";
-import { n as pluginCatalogRuntime } from "./catalog-runtime-XH_LFA_7.js";
-import { a as parseSkillInvocation, n as findSkillByName, r as loadSkillsByName, t as discoverSkills } from "./skills-BoS3b8cg.js";
-import { A as TURN_CONTEXT_TAG, C as isContinuablePiBoundary, D as retainRuntimeTurnContext, E as normalizeToolNameFromResult, H as recordAuthorizationRequested, I as loadTurnRoute, K as recordToolExecutionStarted, L as openConversationProjection, N as loadConnectedMcpProviders, O as stripRuntimeTurnContext, P as loadConversationProjection, R as recordAgentsInstructionsUpdated, S as isAssistantMessage, T as isToolResultMessage, U as recordGuardianActionReviewed, W as recordMcpProviderConnected, _ as getPiMessageRole, b as hasRuntimeTurnContext, dt as estimateTextTokens, f as TurnSliceLimitExceededError, ft as getAgentContextCompactionTriggerTokens, g as extractAssistantText, h as isTurnExecutionLimitExceededError, ht as piMessageFromHistoryItem, k as trimTrailingAssistantMessages, mt as historyItemFromPiMessage, n as loadTurnCheckpoint, p as assertTurnToolCallLimit, pt as getAgentContextInputLimitTokens, q as recordTurnRoute, r as saveTurnCheckpoint, t as continuableMessages, v as getTerminalAssistantMessages, w as isToolResultError, y as getUserMessageInstructionText, z as recordAttachmentsDelivered } from "./checkpoint-CRod8es5.js";
-import { n as generateShortTitle, r as resolveTaskTitle, t as fallbackShortTitle } from "./short-title-CB2fxEyx.js";
-import { A as sleep$1, D as fenceLock, E as acquireActiveLock, F as sandboxSkillDir, I as sandboxSkillFile, L as sandboxSkillPathResolution, M as SANDBOX_REPOS_ROOT, N as SANDBOX_SKILLS_ROOT, P as SANDBOX_WORKSPACE_ROOT, _ 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_DATA_ROOT, k as withLock, 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-DbG8AlNd.js";
-import { $ as workspaceSnapshotFinishedEvent, B as createEventAutomation, C as SCHEDULED_AUTOMATION_SYSTEM_ACTOR, D as eventAutomationMatchesDestination, E as eventAutomationListToolResultSchema, F as effectiveTaskOutcomes, Gt as makeStructuredToolOutput, I as moveTaskOutcomes, Jt as ToolInputError, L as resolveTaskOutcomes, M as requireEventAutomationSlackContext, N as requireSupportedEventAutomationTrigger, O as eventAutomationToolResult, P as writableEventAutomation, Q as WORKSPACE_SNAPSHOT_READY_EVENT, R as taskOutcomeInputSchema, T as compactEventAutomation, Ut as injectContinuationToolName, V as deleteEventAutomation, W as getEventAutomation, Wt as juniorToolOutputSchema, X as getEventCatalog, Y as saveEventAutomation, Z as WORKSPACE_SNAPSHOT_FAILED_EVENT, at as normalizeCatalogEventIdentifier, c as parseSlackThreadId, ct as registeredEventTypeSchema, et as workspaceSnapshotWatch, f as createScheduledAutomation, g as listScheduledAutomationsForTeam, i as readLiveAttachment, it as hasPluginEventCatalogEntries, j as registeredEventAutomationTriggerSchema, k as eventAutomationToolResultSchema, lt as registeredResourceTypeSchema, nt as eventNamespaceSchema, ot as pluginSupportsEvent, pt as appendAndEnqueueInboundMessage, q as listEventAutomationsForTeam, rt as hasEventCatalogEntries, s as storeAttachments, st as registeredEventMatchSchema, t as incrementStat, tt as eventGuidance, ut as requireSupportedEventMatch, v as readScheduledAutomation, y as saveScheduledAutomation } from "./stats-qUXQZq-w.js";
-import { _ as isTurnInputCommitLostError, c as sanitizeAssistantText, f as CooperativeTurnYieldError, l as NO_REPLY_MARKER, n as canReusePendingAuthLink, o as decideReply, p as TurnInputCommitLostError, s as getAssistantReplyText, t as abandonReplacedPendingAuth, u as isNoReplyMarker } from "./pending-auth-_1Ry-_Bw.js";
-import { C as toolInvocationDestination, S as surfaceFromRun, _ as uploadFilesToConversation, b as assertRunConsistency, h as postSlackMessage, i as formatProviderLabel, m as getSlackMessagePermalink, o as resolveBaseUrl, p as addReactionToMessage, r as deliverOAuthAuthorization, s as startOAuthFlow, v as RetryableDeliveryError, x as isAgentRunFeatureDisabled, y as actorFromRun } from "./agent-runner-D0ImXS7U.js";
-import { r as EVENT_AUTHOR_ID } from "./prompt-B8rCQI7K.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-D5SqDbCA.js";
+import { a as resolveAuthTokenPlaceholder, c as fetchWithBoundedOAuthErrorBodies, d as CredentialUnavailableError, i as resolvePluginHeaderEnvRefs, l as getOAuthProviderErrorAttributes, o as resolvePluginCommandEnv, s as OAuthProviderError } from "./registry-Ctgdjt-W.js";
+import { n as pluginCatalogRuntime } from "./catalog-runtime-CVZ9TEuK.js";
+import { a as parseSkillInvocation, n as findSkillByName, r as loadSkillsByName, t as discoverSkills } from "./skills-c2bMDVRS.js";
+import { C as isToolResultError, D as stripRuntimeTurnContext, E as retainRuntimeTurnContext, F as loadTurnRoute, G as recordToolExecutionStarted, H as recordGuardianActionReviewed, I as openConversationProjection, K as recordTurnRoute, L as recordAgentsInstructionsUpdated, M as loadConnectedMcpProviders, N as loadConversationProjection, O as trimTrailingAssistantMessages, R as recordAttachmentsDelivered, S as isContinuablePiBoundary, T as normalizeToolNameFromResult, U as recordMcpProviderConnected, V as recordAuthorizationRequested, _ as getTerminalAssistantMessages, d as TurnSliceLimitExceededError, dt as getAgentContextCompactionTriggerTokens, f as assertTurnToolCallLimit, ft as getAgentContextInputLimitTokens, g as getPiMessageRole, h as extractAssistantText, i as abandonTurnRecord, k as TURN_CONTEXT_TAG, m as isTurnExecutionLimitExceededError, mt as piMessageFromHistoryItem, n as loadTurnCheckpoint, pt as historyItemFromPiMessage, r as saveTurnCheckpoint, t as continuableMessages, ut as estimateTextTokens, v as getUserMessageInstructionText, w as isToolResultMessage, x as isAssistantMessage, y as hasRuntimeTurnContext } from "./checkpoint-Ceck_fLO.js";
+import { n as generateShortTitle, r as resolveTaskTitle, t as fallbackShortTitle } from "./short-title-xEkZwkcV.js";
+import { A as SANDBOX_DATA_ROOT, 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$1, 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-6KWhg_-U.js";
+import { $ as workspaceSnapshotFinishedEvent, B as createEventAutomation, C as SCHEDULED_AUTOMATION_SYSTEM_ACTOR, D as eventAutomationMatchesDestination, E as eventAutomationListToolResultSchema, F as effectiveTaskOutcomes, Gt as makeStructuredToolOutput, I as moveTaskOutcomes, Jt as ToolInputError, L as resolveTaskOutcomes, M as requireEventAutomationSlackContext, N as requireSupportedEventAutomationTrigger, O as eventAutomationToolResult, P as writableEventAutomation, Q as WORKSPACE_SNAPSHOT_READY_EVENT, R as taskOutcomeInputSchema, T as compactEventAutomation, Ut as injectContinuationToolName, V as deleteEventAutomation, W as getEventAutomation, Wt as juniorToolOutputSchema, X as getEventCatalog, Y as saveEventAutomation, Z as WORKSPACE_SNAPSHOT_FAILED_EVENT, at as normalizeCatalogEventIdentifier, c as parseSlackThreadId, ct as registeredEventTypeSchema, et as workspaceSnapshotWatch, f as createScheduledAutomation, g as listScheduledAutomationsForTeam, i as readLiveAttachment, it as hasPluginEventCatalogEntries, j as registeredEventAutomationTriggerSchema, k as eventAutomationToolResultSchema, lt as registeredResourceTypeSchema, nt as eventNamespaceSchema, ot as pluginSupportsEvent, pt as appendAndEnqueueInboundMessage, q as listEventAutomationsForTeam, qt as buildDeterministicTurnId, rt as hasEventCatalogEntries, s as storeAttachments, st as registeredEventMatchSchema, t as incrementStat, tt as eventGuidance, ut as requireSupportedEventMatch, v as readScheduledAutomation, y as saveScheduledAutomation } from "./stats-DP9zl3Jg.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-BIijVS2N.js";
+import { r as EVENT_AUTHOR_ID } from "./prompt-90miy8VV.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-CB45ZukQ.js";
 import { t as getVercelConversationWorkQueue } from "./vercel-queue-DIkVcfK4.js";
-import { a as getTurnRequestDeadline, n as sendNextWorkspaceSnapshotJob, r as sendWorkspaceSnapshotJob } from "./job-queue-_8gxwDzt.js";
+import { a as getTurnRequestDeadline, n as sendNextWorkspaceSnapshotJob, r as sendWorkspaceSnapshotJob } from "./job-queue-D4oAVrL9.js";
 import { n as privateTraceResultAttributes } from "./private-trace-result-BLvBjy_e.js";
 import { streamSimple } from "@earendil-works/pi-ai/compat";
 import { createGatewayProvider } from "@ai-sdk/gateway";
@@ -31,9 +31,9 @@ import path from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { z } from "zod";
-import { createHash, createHmac, randomUUID, timingSafeEqual } from "node:crypto";
+import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { and, desc, eq, gt, gte, inArray, isNull, lt, ne, notExists, or, sql } from "drizzle-orm";
-import { EgressAuthRequired, EgressPolicyDenied, PluginToolInputError, actorSchema, destinationSchema, eventSchema, missingToolAnnotationKeys, pluginAuthorizationSchema, pluginCredentialHeaderTransformSchema, pluginCredentialResultSchema, pluginGrantSchema, pluginProviderAccountSchema, pluginStoredTokensSchema, sourceSchema, stableEventMatchKey, watchResultSchema } from "@sentry/junior-plugin-api";
+import { EgressAuthRequired, EgressPolicyDenied, PluginToolInputError, actorSchema, destinationSchema, eventSchema, missingToolAnnotationKeys, 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";
@@ -1140,6 +1140,73 @@ var AuthorizationFlowDisabledError = class extends Error {
 	}
 };
 //#endregion
+//#region src/chat/agent/types.ts
+/** Resume the agent turn after a transient or ambiguous delivery failure. */
+var RetryableDeliveryError = class extends Error {
+	constructor(cause) {
+		super("Assistant delivery was transient or ambiguous", { cause });
+		this.name = "RetryableDeliveryError";
+	}
+};
+/** Return whether one optional agent capability is disabled for this run. */
+function isAgentRunFeatureDisabled(disabledFeatures, feature) {
+	return disabledFeatures?.includes(feature) ?? false;
+}
+/** Resolve the explicit actor, dispatch actor, or credential actor for this run. */
+function actorFromRun(run) {
+	if (run.dispatch?.actor) return run.dispatch.actor;
+	if (run.actor) return run.actor;
+	if (run.credentialContext && !("type" in run.credentialContext.actor)) return run.credentialContext.actor;
+}
+/** Reject contradictory provider coordinates before the run touches state. */
+function assertRunConsistency(run) {
+	const { destination, source } = run;
+	switch (source.kind) {
+		case "slack":
+			if (destination.platform !== "slack") throw new TypeError("Run source and destination platforms do not match");
+			if (source.teamId !== destination.teamId) throw new TypeError("Slack source and destination teams do not match");
+			break;
+		case "local":
+			if (destination.platform !== "local") throw new TypeError("Run source and destination platforms do not match");
+			if (source.conversationId !== destination.conversationId) throw new TypeError("Source and destination conversation IDs do not match");
+			if (run.surface !== "internal" && destination.conversationId !== run.conversationId) throw new TypeError("Source, destination, and run conversation IDs do not match");
+			break;
+		case "web":
+			if (run.surface !== "internal" && source.conversationId !== run.conversationId) throw new TypeError("Web source and run conversation IDs do not match");
+			switch (destination.platform) {
+				case "local":
+					if (source.conversationId !== destination.conversationId) throw new TypeError("Source and destination conversation IDs do not match");
+					if (run.surface !== "internal" && destination.conversationId !== run.conversationId) throw new TypeError("Source, destination, and run conversation IDs do not match");
+			}
+			break;
+		case "event":
+		case "scheduled_automation":
+		case "event_automation":
+		case "plugin_dispatch":
+		case "agent_invocation": return;
+	}
+	const actor = run.dispatch?.actor ?? run.actor;
+	if (!actor || actor.platform === "system") return;
+	if (actor.platform !== source.kind) throw new TypeError(`Actor platform "${actor.platform}" does not match Source kind "${source.kind}"`);
+	if (actor.platform === "slack" && source.kind === "slack" && actor.teamId !== source.teamId) throw new TypeError("Slack Actor team does not match Source team");
+}
+/** Route tool side effects to the tool channel when one overrides the destination. */
+function toolInvocationDestination(run) {
+	if (run.destination.platform !== "slack" || !run.toolChannelId) return run.destination;
+	return {
+		platform: "slack",
+		teamId: run.destination.teamId,
+		channelId: run.toolChannelId
+	};
+}
+/** Infer the run surface when the caller did not state one. */
+function surfaceFromRun(run) {
+	if (run.surface) return run.surface;
+	if (run.source.kind === "slack") return "slack";
+	if (run.source.kind === "web") return "api";
+	return "internal";
+}
+//#endregion
 //#region src/chat/tool-support/action-review-history.ts
 const MAX_VISIBLE_HISTORY_CHARS = 12e3;
 const priorRejectionSchema = z.object({
@@ -1483,7 +1550,7 @@ const TOOL_POLICY_RULES = [
 	"- For user-provided URLs, use `webFetch`; for discovery, use `webSearch` then fetch/read promising sources; for current time/date context, use `systemTime`.",
 	"- When searchEventTypes is exposed, use it only when the user asks what events are supported or the required resource type or event name is unclear. It discovers options but does not watch a resource or create an automation. When explaining how results can be used, distinguish temporary current-thread watches from durable event automations.",
 	"- When a tool result includes a subscription, those events are already watched; do not call watchEvents for them. When a tool result includes a subscribable resource with suggestedEvents, use watchEvents only for those remaining events that serve the current intent. If suggestedEvents is empty or omitted, do not invent a watch. Do not create scheduled polling tasks for events a watch can deliver. Write a concise intent summary, and tell the user when the temporary watch expires. Stop only the requested watch by id unless the user explicitly asks to stop every watch in the thread.",
-	"- Successful automation changes include cards that the runtime attaches to your next visible reply. Explain what changed; do not repeat the card fields or draw a card in text.",
+	"- Cards returned by tools attach to your next visible reply automatically. Explain the outcome; do not repeat the card fields or draw a card in text.",
 	"- Use createEventAutomation only when the user explicitly asks for an event automation or durable whenever-this-happens-do-X automation. Ordinary watch, notify, and tell-me-when requests use watchEvents. When an event automation's resource and events are known, create it without redundant confirmation.",
 	"- Event automations make the automation creator's connected credentials available by default when the requested work needs user-bound authorization. Do not ask for separate confirmation merely to use credentials needed for the requested work. On creation, omit credentialMode for the creator default and set system only when the creator explicitly requires it. For later changes, creator always means the automation's original createdBy actor, never the current requester. If the requester is not that creator, do not attempt to enable creator credential use or suggest that confirmation could authorize it.",
 	"- Event automations list for the current destination, not one thread. Public automations can also be updated or deleted by automation id from another destination in the same workspace. When listing them, use createdBy to explain creator-only credential changes and warn when trigger.available is false; an unavailable automation remains stored but cannot receive events until its plugin event is enabled again.",
@@ -2524,6 +2591,570 @@ function formatSandboxCommandResult(params) {
 	});
 }
 //#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 threadTs = input.threadTs ? requireSlackThreadTimestamp(input.threadTs, "Slack thread message posting") : void 0;
+	const response = await withSlackRetries(() => getSlackClient().chat.postMessage({
+		channel: channelId,
+		text,
+		unfurl_links: false,
+		unfurl_media: false,
+		...input.blocks?.length ? { blocks: input.blocks } : void 0,
+		...input.entities?.length ? { metadata: { entities: input.entities } } : void 0,
+		...threadTs ? { thread_ts: threadTs } : void 0
+	}), 3, {
+		action: "chat.postMessage",
+		spanAttributes: {
+			"app.slack.channel_id": channelId,
+			...threadTs ? { "app.slack.thread_ts": threadTs } : void 0
+		}
+	});
+	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().reactions.add({
+			channel: channelId,
+			timestamp,
+			name: emoji
+		}), 3, {
+			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());
+}
+//#endregion
+//#region src/chat/slack/oauth-authorization-message.ts
+/** Present private OAuth authorization with a clear action and text fallback. */
+function buildSlackOAuthAuthorizationMessage(args) {
+	return {
+		text: `${formatSlackLink(args.authorizationUrl, args.label)}. ${args.completionText}`,
+		blocks: [{
+			type: "section",
+			text: {
+				type: "mrkdwn",
+				text: `*${escapeSlackMrkdwnText(args.label)}*\n${escapeSlackMrkdwnText(args.completionText)}`
+			},
+			accessory: {
+				type: "button",
+				text: {
+					type: "plain_text",
+					text: "Connect"
+				},
+				style: "primary",
+				url: args.authorizationUrl,
+				action_id: "oauth_connect"
+			}
+		}]
+	};
+}
+//#endregion
+//#region src/chat/oauth-flow.ts
+const OAUTH_STATE_TTL_MS = 6e5;
+function optionalString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+/** Parse OAuth callback state that was persisted before a provider redirect. */
+function parseOAuthStatePayload(value) {
+	if (!isRecord$2(value)) return;
+	if (typeof value.userId !== "string" || typeof value.provider !== "string") return;
+	const actor = value.actor === void 0 ? void 0 : actorSchema.safeParse(value.actor);
+	if (value.actor !== void 0 && (!actor || !actor.success)) return;
+	const destination = parseDestination(value.destination);
+	if (value.destination !== void 0 && !destination) return;
+	const source = value.source === void 0 ? void 0 : sourceSchema.safeParse(value.source);
+	if (value.source !== void 0 && (!source || !source.success)) return;
+	return {
+		userId: value.userId,
+		provider: value.provider,
+		...actor?.success ? { actor: actor.data } : void 0,
+		...optionalString(value.channelId) ? { channelId: optionalString(value.channelId) } : void 0,
+		...destination ? { destination } : void 0,
+		...source?.success ? { source: source.data } : void 0,
+		...optionalString(value.threadTs) ? { threadTs: optionalString(value.threadTs) } : void 0,
+		...optionalString(value.resumeConversationId) ? { resumeConversationId: optionalString(value.resumeConversationId) } : void 0,
+		...optionalString(value.resumeSessionId) ? { resumeSessionId: optionalString(value.resumeSessionId) } : void 0,
+		...optionalString(value.scope) ? { scope: optionalString(value.scope) } : void 0
+	};
+}
+/** Return the manifest-owned display label for a provider. */
+function formatProviderLabel(provider) {
+	const displayName = pluginCatalogRuntime.getDisplayName(provider);
+	if (!displayName) throw new Error(`Unknown plugin provider display name: "${provider}"`);
+	return displayName;
+}
+/** Resolve the public base URL from environment variables (JUNIOR_BASE_URL or Vercel). */
+function resolveBaseUrl() {
+	const explicit = process.env.JUNIOR_BASE_URL?.trim();
+	if (explicit) return explicit;
+	const vercelProd = process.env.VERCEL_PROJECT_PRODUCTION_URL?.trim();
+	if (vercelProd) return `https://${vercelProd}`;
+	const vercelUrl = process.env.VERCEL_URL?.trim();
+	if (vercelUrl) return `https://${vercelUrl}`;
+}
+/**
+* Authorization links must only be visible to the requesting user.
+* Try in-context private delivery first, then fall back to a DM.
+*/
+async function deliverPrivateMessage(input) {
+	let client;
+	try {
+		client = getSlackClient();
+	} catch {
+		logWarn("oauth.private_delivery.skipped", { "app.reason": "missing_bot_token" });
+		return false;
+	}
+	if (input.channelId) try {
+		if (isDmChannel$1(input.channelId)) await postSlackMessage({
+			channelId: input.channelId,
+			text: input.text,
+			blocks: input.blocks,
+			threadTs: input.threadTs
+		});
+		else await postSlackEphemeralMessage({
+			channelId: input.channelId,
+			userId: input.userId,
+			text: input.text,
+			blocks: input.blocks,
+			threadTs: input.threadTs
+		});
+		return "in_context";
+	} catch (error) {
+		logWarn("oauth.private_delivery.failed", {
+			"app.slack.error": error instanceof Error ? error.message : String(error),
+			"app.slack.channel": input.channelId
+		});
+	}
+	try {
+		const dmChannelId = (await withSlackRetries(() => client.conversations.open({ users: input.userId }), 3, {
+			action: "conversations.open",
+			spanAttributes: { "app.slack.user_id": input.userId }
+		})).channel?.id;
+		if (!dmChannelId) {
+			logWarn("oauth.dm.fallback.failed", { "app.reason": "no_dm_channel_id" });
+			return false;
+		}
+		await postSlackMessage({
+			channelId: dmChannelId,
+			text: input.text,
+			blocks: input.blocks
+		});
+		return "fallback_dm";
+	} catch (error) {
+		logWarn("oauth.dm.fallback.failed", { "app.slack.error": error instanceof Error ? error.message : String(error) });
+		return false;
+	}
+}
+/** Present one OAuth request through the active surface's private delivery. */
+async function deliverOAuthAuthorization(request, input) {
+	if (input.authorization) {
+		await input.authorization.deliver(request);
+		return "in_context";
+	}
+	return await deliverPrivateMessage({
+		channelId: input.channelId,
+		threadTs: input.threadTs,
+		userId: input.userId,
+		...buildSlackOAuthAuthorizationMessage(request)
+	});
+}
+/** Initiate an OAuth authorization code flow for a provider and deliver the auth link to the user. */
+async function startOAuthFlow(provider, input) {
+	const providerConfig = pluginCatalogRuntime.getOAuthConfig(provider);
+	if (!providerConfig) return {
+		ok: false,
+		error: `Provider "${provider}" does not support OAuth authorization`
+	};
+	const clientId = process.env[providerConfig.clientIdEnv]?.trim();
+	if (!clientId) return {
+		ok: false,
+		error: `Missing ${providerConfig.clientIdEnv} environment variable`
+	};
+	const baseUrl = resolveBaseUrl();
+	if (!baseUrl) return {
+		ok: false,
+		error: "Cannot determine base URL (set JUNIOR_BASE_URL or deploy to Vercel)"
+	};
+	const state = input.authorization ? await input.authorization.createState() : randomBytes(32).toString("hex");
+	const requestedScope = input.scope ?? providerConfig.scope;
+	await getStateAdapter().set(`oauth-state:${state}`, {
+		userId: input.actorId,
+		provider,
+		...input.actor ? { actor: input.actor } : void 0,
+		...input.channelId ? { channelId: input.channelId } : void 0,
+		...input.destination ? { destination: input.destination } : void 0,
+		...input.source ? { source: input.source } : void 0,
+		...input.threadTs ? { threadTs: input.threadTs } : void 0,
+		...input.resumeConversationId ? { resumeConversationId: input.resumeConversationId } : void 0,
+		...input.resumeSessionId ? { resumeSessionId: input.resumeSessionId } : void 0,
+		...requestedScope ? { scope: requestedScope } : void 0
+	}, OAUTH_STATE_TTL_MS);
+	const authorizeParams = new URLSearchParams({
+		client_id: clientId,
+		state,
+		redirect_uri: `${baseUrl}${providerConfig.callbackPath}`,
+		response_type: "code"
+	});
+	if (requestedScope) authorizeParams.set("scope", requestedScope);
+	for (const [key, value] of Object.entries(providerConfig.authorizeParams ?? {})) authorizeParams.set(key, value);
+	logInfo("jr_rpc.oauth.started", {
+		"app.credential.provider": provider,
+		...input.activeSkillName ? { "app.skill.name": input.activeSkillName } : void 0
+	});
+	return {
+		ok: true,
+		delivery: await deliverOAuthAuthorization({
+			authorizationUrl: `${providerConfig.authorizeEndpoint}?${authorizeParams.toString()}`,
+			label: `Connect to ${formatProviderLabel(provider)}`,
+			completionText: input.resumeSessionId ? "Once you've authorized, Junior will continue automatically." : "Once you've authorized, you'll see a confirmation in Slack."
+		}, {
+			authorization: input.authorization,
+			channelId: input.channelId,
+			threadTs: input.threadTs,
+			userId: input.actorId
+		})
+	};
+}
+//#endregion
 //#region src/chat/sandbox/egress/schemas.ts
 const finiteNumberSchema = z.number().refine(Number.isFinite);
 const httpStatusSchema = z.number().int().min(100).max(599);
@@ -6824,13 +7455,16 @@ var McpToolManager = class {
 							providerContent,
 							...result.structuredContent !== void 0 ? { structuredContent: result.structuredContent } : void 0
 						};
-						await this.options.onToolSuccess?.({
+						const cards = await this.options.onToolSuccess?.({
 							arguments: resolvedArgs,
 							provider: plugin.manifest.name,
 							...result.structuredContent !== void 0 ? { structuredContent: result.structuredContent } : void 0,
 							toolName: tool.name
 						});
-						return successResult;
+						return cards?.length ? {
+							...successResult,
+							cards
+						} : successResult;
 					} catch (error) {
 						if (error instanceof McpAuthorizationRequiredError && await this.handleAuthorizationRequired(plugin.manifest.name, error)) {
 							const parkedContent = [{
@@ -7148,6 +7782,7 @@ function createCallMcpToolTool(mcpToolManager) {
 				}
 			};
 		},
+		outputSchema: z.object({ objectCards: z.array(ownedObjectAnnotationSchema) }),
 		execute: async (input, options) => {
 			const { tool_name } = input;
 			const provider = parseMcpProviderFromToolName(tool_name);
@@ -7167,10 +7802,14 @@ function createCallMcpToolTool(mcpToolManager) {
 				});
 				throw new McpToolError(missingToolMessage(tool_name, provider));
 			}
-			return { content: (await mcpTool.execute(resolveMcpArguments(input), {
+			const result = await mcpTool.execute(resolveMcpArguments(input), {
 				conversationPrivacy: options?.conversationPrivacy ?? "private",
 				...options?.toolCallId ? { toolCallId: options.toolCallId } : void 0
-			})).content };
+			});
+			return {
+				content: result.content,
+				details: { objectCards: result.cards ?? [] }
+			};
 		}
 	});
 }
@@ -7928,7 +8567,7 @@ function createEventAutomationTool(context, catalog) {
 			const existing = await getEventAutomation(db, id);
 			if (existing) {
 				if (!eventAutomationMatchesDestination(existing, destination) || existing.createdBy.slackUserId !== actor.userId) throw new ToolInputError("Event automation operation identity is invalid.");
-				if (existing.status !== "deleted") return eventAutomationToolResult(existing, catalog, actor.userId);
+				if (existing.status !== "deleted") return eventAutomationToolResult(context.conversationId, existing, catalog, actor.userId);
 			}
 			const title = await resolveTaskTitle({
 				completeText,
@@ -7958,7 +8597,7 @@ function createEventAutomationTool(context, catalog) {
 					...match ? { match } : void 0
 				}
 			};
-			return eventAutomationToolResult(await createEventAutomation(db, task), catalog, actor.userId);
+			return eventAutomationToolResult(context.conversationId, await createEventAutomation(db, task), catalog, actor.userId);
 		}
 	});
 }
@@ -7977,13 +8616,24 @@ function createDeleteEventAutomationTool(context, catalog) {
 		executionMode: "sequential",
 		description: "Delete an event automation.",
 		inputSchema: z.object({ automationId: z.string().min(1) }).strict(),
-		outputSchema: eventAutomationToolResultSchema.omit({ cards: true }),
+		outputSchema: eventAutomationToolResultSchema.omit({ objectCards: true }).extend({ removedCards: z.array(messageCardRefSchema) }),
 		async execute({ automationId }) {
 			const { actor } = requireEventAutomationSlackContext(context);
 			const current = await writableEventAutomation(context, automationId);
 			const deleted = await deleteEventAutomation(getDb(), current.id);
 			if (!deleted) throw new ToolInputError("Event automation was not found.");
-			return { automation: compactEventAutomation(deleted, catalog, actor.userId) };
+			await createPluginAnnotations({
+				conversationId: context.conversationId,
+				db: getDb(),
+				plugin: "junior"
+			}).remove("object", automationId);
+			return {
+				automation: compactEventAutomation(deleted, catalog, actor.userId),
+				removedCards: [{
+					plugin: "junior",
+					key: automationId
+				}]
+			};
 		}
 	});
 }
@@ -8088,7 +8738,7 @@ function createUpdateEventAutomationTool(context, catalog) {
 			}
 			const saved = await saveEventAutomation(getDb(), next);
 			if (!saved) throw new ToolInputError("Event automation was not found.");
-			return eventAutomationToolResult(saved, catalog, actor.userId);
+			return eventAutomationToolResult(context.conversationId, saved, catalog, actor.userId);
 		}
 	});
 }
@@ -8674,7 +9324,7 @@ const compactTaskResultSchema = z.object({
 }).strict();
 const scheduleAutomationToolResultSchema = juniorToolOutputSchema.extend({
 	automation: compactTaskResultSchema,
-	cards: z.array(automationCardSchema).optional()
+	objectCards: z.array(ownedObjectAnnotationSchema).optional()
 }).strict();
 const scheduleListToolResultSchema = juniorToolOutputSchema.extend({
 	automations: z.array(compactTaskResultSchema),
@@ -8792,23 +9442,27 @@ function compactTask(task, requesterSlackUserId) {
 	});
 }
 /** Build the structured result shared by single-task scheduler tools. */
-function scheduleAutomationToolResult(task, requesterSlackUserId) {
+async function scheduleAutomationToolResult(conversationId, task, requesterSlackUserId) {
 	const automation = compactTask(task, requesterSlackUserId);
+	const title = automation.title ?? fallbackShortTitle(automation.instruction, "Scheduled automation");
+	const annotation = {
+		kind: "object",
+		objectType: "automation",
+		label: title,
+		key: task.id,
+		title,
+		url: automation.dashboardUrl,
+		description: automation.instruction,
+		trigger: task.schedule.kind === "one_off" && task.nextRunAtMs !== void 0 ? `${new Intl.DateTimeFormat("en-US", {
+			dateStyle: "medium",
+			timeStyle: "short",
+			timeZone: task.schedule.timezone
+		}).format(task.nextRunAtMs)} · ${task.schedule.timezone}` : automation.schedule,
+		warning: automation.status === "blocked" ? automation.statusReason ?? "This automation is blocked." : automation.status === "completed" ? "This automation has completed." : void 0
+	};
 	return {
 		automation,
-		cards: [{
-			kind: "automation",
-			id: task.id,
-			title: automation.title ?? fallbackShortTitle(automation.instruction, "Scheduled automation"),
-			url: automation.dashboardUrl,
-			instruction: automation.instruction,
-			trigger: task.schedule.kind === "one_off" && task.nextRunAtMs !== void 0 ? `${new Intl.DateTimeFormat("en-US", {
-				dateStyle: "medium",
-				timeStyle: "short",
-				timeZone: task.schedule.timezone
-			}).format(task.nextRunAtMs)} · ${task.schedule.timezone}` : automation.schedule,
-			warning: automation.status === "blocked" ? automation.statusReason ?? "This automation is blocked." : automation.status === "completed" ? "This automation has completed." : null
-		}]
+		objectCards: await saveObjectAnnotations(conversationId, "junior", [annotation])
 	};
 }
 /** Build the structured result for listing scheduler tools. */
@@ -8879,7 +9533,7 @@ function createSlackScheduleCreateAutomationTool(context) {
 			const existing = await readScheduledAutomation(db, id);
 			if (existing) {
 				if (!sameDestination(existing, destination) || existing.createdBy.slackUserId !== actor.slackUserId) throwToolInputError("Scheduled automation operation identity is invalid.");
-				return scheduleAutomationToolResult(existing, actor.slackUserId);
+				return scheduleAutomationToolResult(context.conversationId, existing, actor.slackUserId);
 			}
 			const identity = (await context.users.resolveActor())?.identity;
 			if (!identity || identity.provider !== "slack" || identity.providerTenantId !== destination.teamId || identity.providerSubjectId !== actor.slackUserId) throwToolInputError("Scheduled automation creator identity is unavailable.");
@@ -8922,7 +9576,7 @@ function createSlackScheduleCreateAutomationTool(context) {
 			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(committed, actor.slackUserId);
+			return scheduleAutomationToolResult(context.conversationId, committed, actor.slackUserId);
 		}
 	});
 }
@@ -8941,7 +9595,7 @@ function createSlackScheduleDeleteAutomationTool(context) {
 		description: "Delete one scheduled Junior task from the active Slack conversation. Use only task IDs returned for this conversation. Do not delete schedules from threads, other channels, or another user's DM.",
 		executionMode: "sequential",
 		inputSchema: z.object({ automationId: z.string().min(1).describe("ID of the task to delete. Must be from this active Slack conversation.") }),
-		outputSchema: scheduleAutomationToolResultSchema,
+		outputSchema: scheduleAutomationToolResultSchema.extend({ removedCards: z.array(messageCardRefSchema) }),
 		execute: async ({ automationId }) => {
 			const next = {
 				...await getWritableTask({
@@ -8954,7 +9608,18 @@ function createSlackScheduleDeleteAutomationTool(context) {
 				runNowAtMs: void 0
 			};
 			await saveScheduledAutomation(getDb(), next);
-			return { automation: compactTask(next, context.actor?.userId) };
+			await createPluginAnnotations({
+				conversationId: context.conversationId,
+				db: getDb(),
+				plugin: "junior"
+			}).remove("object", automationId);
+			return {
+				automation: compactTask(next, context.actor?.userId),
+				removedCards: [{
+					plugin: "junior",
+					key: automationId
+				}]
+			};
 		}
 	});
 }
@@ -9170,10 +9835,10 @@ function createSlackScheduleUpdateAutomationTool(context) {
 				if (title) next.title = title;
 				else delete next.title;
 			}
-			if (!changingDestination && !instructionChanged && !compiled && status === void 0 && (input.credentialMode === void 0 || input.credentialMode === null || input.credentialMode === lookup.credentialMode) && input.outcomes === void 0 && moveDestination) return scheduleAutomationToolResult(lookup, actor.slackUserId);
+			if (!changingDestination && !instructionChanged && !compiled && status === void 0 && (input.credentialMode === void 0 || input.credentialMode === null || input.credentialMode === lookup.credentialMode) && input.outcomes === void 0 && moveDestination) return scheduleAutomationToolResult(context.conversationId, lookup, actor.slackUserId);
 			const committed = await saveScheduledAutomation(db, next);
 			if (changingDestination) logInfo("scheduled_automation.move.completed", scheduledAutomationAttributes(committed));
-			return scheduleAutomationToolResult(committed, actor.slackUserId);
+			return scheduleAutomationToolResult(context.conversationId, committed, actor.slackUserId);
 		}
 	});
 }
@@ -9182,6 +9847,7 @@ function createSlackScheduleUpdateAutomationTool(context) {
 function scheduledAutomationToolContext(context) {
 	if (context.source.kind !== "slack" || context.destination.platform !== "slack" || context.actor?.platform !== "slack" || !context.resolveActorIdentity) return;
 	return {
+		conversationId: context.conversationId,
 		actor: context.actor,
 		source: context.source,
 		users: { resolveActor: context.resolveActorIdentity },
@@ -10185,13 +10851,12 @@ function createSendFilesTool(context, state, materializeFile, attachments) {
 				files: materializedFiles,
 				storage: attachments.storage
 			}) : [];
-			const uploads = materializedFiles.map((file) => ({
-				data: file.data,
-				filename: file.filename
-			}));
 			await uploadFilesToConversation({
 				channelId: activeChannelId,
-				files: uploads,
+				files: materializedFiles.map((file) => ({
+					data: file.data,
+					filename: file.filename
+				})),
 				...threadTs ? { threadTs } : void 0
 			});
 			const delivered = stored.map((attachment, index) => {
@@ -13767,10 +14432,51 @@ function buildSandboxInput(toolName, params) {
 	return params;
 }
 //#endregion
-//#region src/chat/oauth-authorization.ts
-/** Build the stable event identity shared by authorization request and completion. */
-function authorizationId(args) {
-	return `${args.sessionId}:${args.kind}:${args.provider}`;
+//#region src/chat/services/pending-auth.ts
+const AUTH_LINK_REUSE_WINDOW_MS = 6e5;
+const NON_REQUEST_SKIPPED_REASON_PREFIXES = ["directed_to_other_party:", "side_conversation:"];
+function isSkippedNonRequest(reason) {
+	return NON_REQUEST_SKIPPED_REASON_PREFIXES.some((prefix) => reason?.startsWith(prefix));
+}
+/** Decide whether the same agent-run session can reuse its fresh auth link. */
+function canReusePendingAuthLink(args) {
+	const { pendingAuth } = args;
+	if (!pendingAuth) return false;
+	return pendingAuth.kind === args.kind && pendingAuth.provider === args.provider && pendingAuth.actorId === args.actorId && pendingAuth.scope === args.scope && pendingAuth.sessionId === args.sessionId && pendingAuth.linkSentAtMs + AUTH_LINK_REUSE_WINDOW_MS > (args.nowMs ?? Date.now());
+}
+function getConversationPendingAuth(args) {
+	const pendingAuth = args.conversation.processing.pendingAuth;
+	if (!pendingAuth) return;
+	if (pendingAuth.kind !== args.kind || pendingAuth.provider !== args.provider || pendingAuth.actorId !== args.actorId || pendingAuth.scope !== args.scope) return;
+	return pendingAuth;
+}
+function clearPendingAuth(conversation, sessionId) {
+	if (!conversation.processing.pendingAuth) return;
+	if (sessionId && conversation.processing.pendingAuth.sessionId !== sessionId) return;
+	conversation.processing.pendingAuth = void 0;
+}
+/** Mark the prior blocked turn abandoned after a new auth attempt replaces it. */
+async function abandonReplacedPendingAuth(args) {
+	if (args.previousPendingAuth && args.previousPendingAuth.sessionId !== args.nextPendingAuth.sessionId && args.conversationId) await abandonTurnRecord({
+		conversationId: args.conversationId,
+		turnId: args.previousPendingAuth.sessionId,
+		errorMessage: "Abandoned by a newer auth-blocked request in the same conversation."
+	});
+}
+/**
+* Decide whether an auth callback still belongs to the latest real human
+* request, ignoring bot-authored and passive bystander rows while treating
+* failed human turns and opt-outs as newer freshness blockers.
+*/
+function isPendingAuthLatestRequest(conversation, pendingAuth) {
+	for (let index = conversation.messages.length - 1; index >= 0; index -= 1) {
+		const message = conversation.messages[index];
+		if (message?.role !== "user") continue;
+		if (message.author?.isBot) continue;
+		if (isSkippedNonRequest(message.meta?.skippedReason)) continue;
+		return buildDeterministicTurnId(message.id) === pendingAuth.sessionId;
+	}
+	return false;
 }
 //#endregion
 //#region src/chat/services/plugin-auth-orchestration.ts
@@ -15216,12 +15922,11 @@ function createMcpAuthOrchestration(input) {
 			const authSession = await getMcpAuthSession(authSessionId);
 			if (!authSession?.authorizationUrl) throw new Error(`Missing MCP authorization URL for plugin "${provider}"`);
 			await recordPendingAuth(nextPendingAuth);
-			const authorizationRequest = {
+			if (!await deliverOAuthAuthorization({
 				authorizationUrl: authSession.authorizationUrl,
-				label: `Click here to link your ${providerLabel} MCP access`,
+				label: `Connect to ${providerLabel}`,
 				completionText: "Once you've authorized, Junior will continue automatically."
-			};
-			if (!await deliverOAuthAuthorization(authorizationRequest, {
+			}, {
 				authorization: input.authorization,
 				channelId: authSession.channelId,
 				threadTs: authSession.threadTs,
@@ -16395,7 +17100,7 @@ async function wireAgentTools(args) {
 		authProviderFactory: mcpAuth.authProviderFactory,
 		onAuthorizationRequired: mcpAuth.onAuthorizationRequired,
 		onToolSuccess: async (input) => {
-			await pluginHooks.afterMcpTool({
+			return await pluginHooks.afterMcpTool({
 				...input,
 				conversationId: args.run.conversationId
 			});
@@ -17362,7 +18067,7 @@ function applyHandoff(args) {
 * assistant message through the delivery port; the result carries diagnostics,
 * artifacts, and transcript state for destination-owned completion.
 */
-const AGENT_ABORT_SETTLE_GRACE_MS = 5e3;
+const AGENT_ABORT_SETTLE_GRACE_MS$1 = 5e3;
 async function readRunConversationVisibility(conversationId) {
 	const conversationStore = getConversationStore();
 	const conversation = await conversationStore.get({ conversationId });
@@ -18091,7 +18796,7 @@ async function executeAgentRunInPrivacyContext(run, conversationPrivacy, runLogC
 								"app.ai.turn_timeout_ms": turnTimeoutBudgetMs,
 								"app.ai.turn_deadline_remaining_ms": Math.max(0, turnDeadlineAtMs - Date.now())
 							});
-							if (!await waitForAbortSettlement(run, AGENT_ABORT_SETTLE_GRACE_MS)) logWarn("agent.turn.abort_settle.timed_out", { "app.ai.abort_settle_grace_ms": AGENT_ABORT_SETTLE_GRACE_MS });
+							if (!await waitForAbortSettlement(run, AGENT_ABORT_SETTLE_GRACE_MS$1)) logWarn("agent.turn.abort_settle.timed_out", { "app.ai.abort_settle_grace_ms": AGENT_ABORT_SETTLE_GRACE_MS$1 });
 							runResume.captureResumeSnapshot(runResume.getResumeSnapshot(currentAgentMessages()));
 						}
 						const pendingAuthPause = getPendingAuthPause();
@@ -18313,4 +19018,109 @@ async function executeAgentRunInPrivacyContext(run, conversationPrivacy, runLogC
 	}
 }
 //#endregion
-export { AuthorizationFlowDisabledError as $, createAgentInvocationSchema as A, recordFinishedTurnForAutomatedLimit as B, renderBlockText as C, getNextRunAtMs as D, scheduledAutomationRunAttributes as E, ingestEvent as F, clearSandboxEgressSignals as G, normalizeSandboxEgressTracePropagationDomains as H, EVENT_WAIT_MS as I, parseSandboxEgressCredentialToken as J, consumeSandboxEgressAuthRequiredSignal as K, isEventMailboxMetadata as L, AgentInvocationLimitError as M, getMcpProviderErrorAttributes as N, agentBindingSchema as O, processWorkspaceSnapshotJob as P, isVisionImageMediaType as Q, renderTaskInput as R, renderAttachmentText as S, logScheduledAutomationRunSkipped as T, shouldPropagateSandboxEgressTrace as U, resolveSandboxEgressProviderForHost as V, SANDBOX_EGRESS_PROXY_PATH as W, createUserTokenStore as X, sandboxEgressSignalsResponseSchema as Y, buildSteeringPiMessage as Z, readPublicArtifact as _, deleteMcpAuthSession as a, readAttachmentVisionSummary as b, deleteMcpStoredOAuthCredentials as c, putMcpStoredOAuthCredentials as d, shouldEmitDevAgentTrace as et, PluginCredentialFailureError as f, publicArtifactHeaders as g, resolvePluginOAuthAccount as h, finalizeMcpAuthorization as i, AgentInvocationBusyError as j, agentInvocationSchema as k, getMcpAuthSession as l, latestProgressStatus as m, createContextCompactor as n, setConfigDefaults as nt, deleteMcpAuthSessionsForUserProvider as o, authorizationId as p, consumeSandboxEgressPermissionDeniedSignal as q, executeCredentialedEgressRequest as r, deleteMcpServerSessionId as s, executeAgentRun as t, getConfigDefaults as tt, getMcpStoredOAuthCredentials as u, unpublishedArtifactHeaders as v, listThreadReplies as w, recordSlackAttachment as x, lookupSlackUserProfile as y, maybePostAutomatedTurnLimitNotice as z };
+//#region src/chat/experimental.ts
+var experimental_exports = /* @__PURE__ */ __exportAll({
+	EXPERIMENTAL_FEATURES: () => EXPERIMENTAL_FEATURES,
+	getExperimentalFeatures: () => getExperimentalFeatures,
+	isExperimentalFeatureEnabled: () => isExperimentalFeatureEnabled,
+	setExperimentalFeatures: () => setExperimentalFeatures
+});
+/**
+* Known unstable product features that must be opted into explicitly.
+* Add new keys here as features graduate from private experiments; remove them
+* once they become stable defaults.
+*/
+const EXPERIMENTAL_FEATURES = ["passive-routing", "subagents"];
+const EXPERIMENTAL_FEATURE_SET = new Set(EXPERIMENTAL_FEATURES);
+let configuredExperimental = {};
+function isExperimentalFeature(value) {
+	return EXPERIMENTAL_FEATURE_SET.has(value);
+}
+/** Replace app-level experimental opt-ins and return the previous setting. */
+function setExperimentalFeatures(config) {
+	const previous = { ...configuredExperimental };
+	if (config === void 0) {
+		configuredExperimental = {};
+		return previous;
+	}
+	const next = {};
+	for (const [rawName, enabled] of Object.entries(config)) {
+		if (enabled === void 0) continue;
+		if (typeof enabled !== "boolean") throw new Error(`experimental.${rawName} must be a boolean when provided`);
+		if (!isExperimentalFeature(rawName)) throw new Error(`experimental.${rawName} is not a known experimental feature. Known features: ${EXPERIMENTAL_FEATURES.join(", ")}`);
+		next[rawName] = enabled;
+	}
+	configuredExperimental = next;
+	return previous;
+}
+/** Return a copy of the app-level experimental opt-ins configured by createApp(). */
+function getExperimentalFeatures() {
+	return { ...configuredExperimental };
+}
+/** Return whether one experimental feature is enabled via createApp({ experimental }). */
+function isExperimentalFeatureEnabled(feature) {
+	return configuredExperimental[feature] === true;
+}
+//#endregion
+//#region src/chat/runtime/agent-runner.ts
+const AGENT_ABORT_SETTLE_GRACE_MS = 5e3;
+/** Compose the agent executor with stable host dependencies. */
+function createAgentRunner(execute, options) {
+	const attachmentStorage = options?.attachmentStorage;
+	const streamFn = options?.streamFn;
+	const tracePropagation = options?.tracePropagation;
+	const bindSpawnAgent = options?.bindSpawnAgent;
+	const canBindSpawn = Boolean(bindSpawnAgent) && isExperimentalFeatureEnabled("subagents");
+	return { run: async (run) => {
+		const spawnAgent = bindSpawnAgent && canBindSpawn && !isAgentRunFeatureDisabled(run.disabledFeatures, "subagents") ? bindSpawnAgent(run) : void 0;
+		return await execute({
+			...run,
+			environment: {
+				...run.environment,
+				attachmentStorage: run.environment?.attachmentStorage ?? attachmentStorage,
+				sandboxTracePropagation: run.environment?.sandboxTracePropagation ?? tracePropagation
+			},
+			...spawnAgent ? { durability: {
+				...run.durability,
+				spawnAgent
+			} } : void 0
+		}, streamFn);
+	} };
+}
+async function waitForAgentSettlement(runPromise) {
+	let timeoutId;
+	const settleGrace = new Promise((resolve) => {
+		timeoutId = setTimeout(resolve, AGENT_ABORT_SETTLE_GRACE_MS);
+		timeoutId.unref?.();
+	});
+	await Promise.race([runPromise.then(() => void 0, () => void 0), settleGrace]);
+	if (timeoutId) clearTimeout(timeoutId);
+}
+/** Abort a timed-out agent run and wait briefly for its work to settle. */
+async function runAgentWithTimeout(agentRunner, run, timeoutMs) {
+	if (typeof timeoutMs !== "number") return await agentRunner.run(run);
+	const timeoutError = /* @__PURE__ */ new Error(`executeAgentRun timed out after ${timeoutMs}ms`);
+	const abortController = new AbortController();
+	const signal = run.signal ? AbortSignal.any([run.signal, abortController.signal]) : abortController.signal;
+	const runPromise = agentRunner.run({
+		...run,
+		signal
+	});
+	let timeoutId;
+	const timeoutPromise = new Promise((_, reject) => {
+		timeoutId = setTimeout(() => {
+			abortController.abort(timeoutError);
+			reject(timeoutError);
+		}, timeoutMs);
+	});
+	try {
+		return await Promise.race([runPromise, timeoutPromise]);
+	} catch (error) {
+		if (abortController.signal.aborted) await waitForAgentSettlement(runPromise);
+		throw error;
+	} finally {
+		if (timeoutId) clearTimeout(timeoutId);
+	}
+}
+//#endregion
+export { clearSandboxEgressSignals as $, renderAttachmentText as A, AgentInvocationLimitError as B, resolvePluginOAuthAccount as C, shouldEmitDevAgentTrace as Ct, lookupSlackUserProfile as D, unpublishedArtifactHeaders as E, getNextRunAtMs as F, isEventMailboxMetadata as G, processWorkspaceSnapshotJob as H, agentBindingSchema as I, recordFinishedTurnForAutomatedLimit as J, renderTaskInput as K, agentInvocationSchema as L, listThreadReplies as M, logScheduledAutomationRunSkipped as N, readAttachmentVisionSummary as O, scheduledAutomationRunAttributes as P, SANDBOX_EGRESS_PROXY_PATH as Q, createAgentInvocationSchema as R, latestProgressStatus as S, AuthorizationFlowDisabledError as St, readPublicArtifact as T, setConfigDefaults as Tt, ingestEvent as U, getMcpProviderErrorAttributes as V, EVENT_WAIT_MS as W, normalizeSandboxEgressTracePropagationDomains as X, resolveSandboxEgressProviderForHost as Y, shouldPropagateSandboxEgressTrace as Z, putMcpStoredOAuthCredentials as _, buildSteeringPiMessage as _t, isExperimentalFeatureEnabled as a, parseOAuthStatePayload as at, getConversationPendingAuth as b, actorFromRun as bt, createContextCompactor as c, escapeSlackMrkdwnText as ct, deleteMcpAuthSession as d, normalizeSlackStatusText as dt, consumeSandboxEgressAuthRequiredSignal as et, deleteMcpAuthSessionsForUserProvider as f, truncateStatusText as ft, getMcpStoredOAuthCredentials as g, createUserTokenStore as gt, getMcpAuthSession as h, removeReactionFromMessage as ht, getExperimentalFeatures as i, formatProviderLabel as it, renderBlockText as j, recordSlackAttachment as k, executeCredentialedEgressRequest as l, formatSlackLink as lt, deleteMcpStoredOAuthCredentials as m, postSlackMessage as mt, runAgentWithTimeout as n, parseSandboxEgressCredentialToken as nt, setExperimentalFeatures as o, resolveBaseUrl as ot, deleteMcpServerSessionId as p, addReactionToMessage as pt, maybePostAutomatedTurnLimitNotice as q, experimental_exports as r, sandboxEgressSignalsResponseSchema as rt, executeAgentRun as s, startOAuthFlow as st, createAgentRunner as t, consumeSandboxEgressPermissionDeniedSignal as tt, finalizeMcpAuthorization as u, normalizeSlackReplyMarkdown as ut, PluginCredentialFailureError as v, isVisionImageMediaType as vt, publicArtifactHeaders as w, getConfigDefaults as wt, isPendingAuthLatestRequest as x, toolInvocationDestination as xt, clearPendingAuth as y, RetryableDeliveryError as yt, AgentInvocationBusyError as z };