@sentry/junior 0.263.0 → 0.265.0

package/dist/{agent-runner-BUBas7Yy.js → agent-runner-C6MwHJEs.js}

@@ -1,32 +1,31 @@
-import { $t as isToolResultMessage, An as createSandboxEgressCredentialToken, B as recordAttachmentsDelivered, Ct as canReusePendingAuthLink, Dn as clearSandboxEgressSignals, Dt as continuableMessages, G as recordMcpProviderConnected, Gn as getSlackMessagePermalink, Gt as getPiMessageRole, Hn as slackMention, Ht as isTurnExecutionLimitExceededError, In as resolveBaseUrl, It as TURN_LIMIT_DISABLED_REASON, J as recordTurnRoute, Jt as hasRuntimeTurnContext, Kn as openSlackDirectMessage, Kt as getTerminalAssistantMessages, L as loadTurnRoute, Lt as TurnBudgetExceededError, M as loadConnectedMcpProviders, N as loadConversationProjection, Nn as deliverOAuthAuthorization, O as automationRevision, On as consumeSandboxEgressAuthRequiredSignal, Ot as loadTurnCheckpoint, P as loadLastModelProfile, Pn as formatProviderLabel, Qn as getOAuthAccountProviders, Qt as isToolResultError, R as openConversationProjection, Rt as TurnSliceLimitExceededError, Sn as resolveSandboxCommandEnvironment, St as abandonReplacedPendingAuth, U as recordAuthorizationRequested, Vt as createTurnLimitGate, W as recordGuardianActionReviewed, Wn as addReactionToMessage, Wt as extractAssistantText, Xt as isAssistantMessage, Yn as uploadFilesToConversation, Zt as isContinuablePiBoundary, _n as isExperimentalFeatureEnabled, _t as createPluginAuthOrchestration, a as saveScheduledAutomation, an as SESSION_CONTEXT_SECTION_TAG, bn as createUserTokenStore, bt as AuthorizationFlowDisabledError, d as createEventAutomation, en as normalizeToolNameFromResult, f as deleteEventAutomation, g as listEventAutomationsForTeam, gt as PluginCredentialFailureError, hn as getAgentContextInputLimitTokens, ht as createPluginEgress, i as readScheduledAutomation, in as REQUEST_CONTEXT_SECTION_TAG, ir as getConfigDefaults, kn as consumeSandboxEgressPermissionDeniedSignal, kt as saveTurnCheckpoint, m as getEventAutomation, mn as getAgentContextCompactionTriggerTokens, n as listScheduledAutomationsForTeam, nn as stripRuntimeTurnContext, nr as historyItemFromPiMessage, nt as fallbackShortTitle, on as TURN_CONTEXT_TAG, pn as estimateTextTokens, q as recordToolExecutionStarted, qt as getUserMessageInstructionText, rn as trimTrailingAssistantMessages, rr as piMessageFromHistoryItem, rt as resolveTaskTitle, t as createScheduledAutomation, tn as retainRuntimeTurnContext, v as saveEventAutomation, vt as authorizationId, xn as buildSandboxEgressNetworkPolicy, xt as AuthorizationPauseError, y as setEventAutomationStatus, yt as AuthPausePersistenceError, z as recordAgentsInstructionsUpdated, zt as TurnToolCallLimitExceededError } from "./tasks-LOItiYgL.js";
-import { S as resolveGatewayCredential, _ as getProviderErrorAttributes, a as completeText, b as MISSING_GATEWAY_CREDENTIALS_ERROR, c as COMPACTION_SUMMARY_PREFIX, d as renderCurrentInstruction, f as unwrapCurrentInstruction, g as findProviderError, h as createProviderError, i as completeObject, l as hasCompactedConversationContext, m as ProviderError, n as GEN_AI_SERVER_ADDRESS, p as escapeXml, s as resolveGatewayModel, t as GEN_AI_PROVIDER_NAME, u as isCompactionSummaryText, x as getGatewayApiKey, y as isProviderRetryError } from "./client-DZBCBj1M.js";
-import { R as normalizeIdentityEmail, S as summarizeMessageText, T as withSpan, V as toOptionalString, _ as serializeGenAiAttribute, a as extractGenAiUsageSummary, b as setSpanStatus, c as getLogContextAttributesForSpan, d as logError, f as logException, h as normalizeGenAiFinishReason, i as extractGenAiUsageAttributes, l as getTracePropagationHeaders, m as logWarn, p as logInfo, w as withLogContext, x as setTags, y as setSpanAttributes, z as isRecord$4 } from "./logging-Dk_FpF36.js";
-import { m as startInactiveSpan, v as withActiveSpan } from "./sentry-BBUlHih9.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-FY8yc2q3.js";
-import { n as botConfig, v as normalizeSlackEmojiName } from "./config-Dnv8KmNs.js";
+import { $t as isToolResultMessage, B as recordAttachmentsDelivered, Cn as getConfigDefaults, Ct as canReusePendingAuthLink, Dt as continuableMessages, G as recordMcpProviderConnected, Gt as getPiMessageRole, Ht as isTurnExecutionLimitExceededError, It as TURN_LIMIT_DISABLED_REASON, J as recordTurnRoute, Jt as hasRuntimeTurnContext, Kt as getTerminalAssistantMessages, L as loadTurnRoute, Lt as TurnBudgetExceededError, M as loadConnectedMcpProviders, N as loadConversationProjection, O as automationRevision, Ot as loadTurnCheckpoint, P as loadLastModelProfile, Qt as isToolResultError, R as openConversationProjection, Rt as TurnSliceLimitExceededError, Sn as piMessageFromHistoryItem, St as abandonReplacedPendingAuth, U as recordAuthorizationRequested, Vt as createTurnLimitGate, W as recordGuardianActionReviewed, Wt as extractAssistantText, Xt as isAssistantMessage, Zt as isContinuablePiBoundary, _n as isExperimentalFeatureEnabled, _t as createPluginAuthOrchestration, a as saveScheduledAutomation, an as SESSION_CONTEXT_SECTION_TAG, bt as AuthorizationFlowDisabledError, d as createEventAutomation, en as normalizeToolNameFromResult, f as deleteEventAutomation, g as listEventAutomationsForTeam, gt as PluginCredentialFailureError, hn as getAgentContextInputLimitTokens, ht as createPluginEgress, i as readScheduledAutomation, in as REQUEST_CONTEXT_SECTION_TAG, kt as saveTurnCheckpoint, m as getEventAutomation, mn as getAgentContextCompactionTriggerTokens, n as listScheduledAutomationsForTeam, nn as stripRuntimeTurnContext, nt as fallbackShortTitle, on as TURN_CONTEXT_TAG, pn as estimateTextTokens, q as recordToolExecutionStarted, qt as getUserMessageInstructionText, rn as trimTrailingAssistantMessages, rt as resolveTaskTitle, t as createScheduledAutomation, tn as retainRuntimeTurnContext, v as saveEventAutomation, vt as authorizationId, xn as historyItemFromPiMessage, xt as AuthorizationPauseError, y as setEventAutomationStatus, yt as AuthPausePersistenceError, z as recordAgentsInstructionsUpdated, zt as TurnToolCallLimitExceededError } from "./tasks-DGbrur6x.js";
+import { S as resolveGatewayCredential, _ as getProviderErrorAttributes, a as completeText, b as MISSING_GATEWAY_CREDENTIALS_ERROR, c as COMPACTION_SUMMARY_PREFIX, d as renderCurrentInstruction, f as unwrapCurrentInstruction, g as findProviderError, h as createProviderError, i as completeObject, l as hasCompactedConversationContext, m as ProviderError, n as GEN_AI_SERVER_ADDRESS, p as escapeXml, s as resolveGatewayModel, t as GEN_AI_PROVIDER_NAME, u as isCompactionSummaryText, x as getGatewayApiKey, y as isProviderRetryError } from "./client-DX34VNtH.js";
+import { n as botConfig, v as normalizeSlackEmojiName } from "./config-BayQ9hHH.js";
+import { R as normalizeIdentityEmail, S as summarizeMessageText, T as withSpan, V as toOptionalString, _ as serializeGenAiAttribute, a as extractGenAiUsageSummary, b as setSpanStatus, c as getLogContextAttributesForSpan, d as logError, f as logException, h as normalizeGenAiFinishReason, i as extractGenAiUsageAttributes, l as getTracePropagationHeaders, m as logWarn, p as logInfo, w as withLogContext, x as setTags, y as setSpanAttributes, z as isRecord$4 } from "./logging-D2QBriUo.js";
+import { g as withActiveSpan, m as startInactiveSpan } from "./sentry-MDkYAVPV.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-frjQCJa9.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-Bg8EoCKD.js";
 import { a as isUserActor, d as parseSlackTeamId, f as parseSlackUserId, g as parseSlackMessageTs, l as parseSlackChannelId, u as parseSlackChannelReferenceId } from "./actor-tlxzqaRe.js";
-import { C as addAgentTurnUsage, D as hasAgentTurnUsage, R as parseDestination, c as getConversationEventStore, d as getDb, f as getSqlExecutor, l as getConversationMessageSearchStore, r as readActorIdentity, u as getConversationStore, w as agentTurnCostUsd } from "./viewer-DmNRM88V.js";
+import { O as hasAgentTurnUsage, T as agentTurnCostUsd, d as getConversationStore, f as getDb, l as getConversationEventStore, p as getSqlExecutor, r as readActorIdentity, u as getConversationMessageSearchStore, w as addAgentTurnUsage, z as parseDestination } from "./viewer-B2wXNspU.js";
 import { a as juniorAgentInvocations, c as juniorIdentities, d as juniorDestinations, i as juniorAgentBindings, s as juniorConversations } from "./agent-invocations-CxKldAeB.js";
-import { _ as juniorConversationAnnotations, a as juniorAutomationRuns, b as juniorAttachments, c as juniorStats, f as juniorConversationBriefs, x as juniorArtifacts } from "./executor-J9k2sp9m.js";
+import { _ as juniorConversationAnnotations, a as juniorAutomationRuns, b as juniorAttachments, c as juniorStats, f as juniorConversationBriefs, x as juniorArtifacts } from "./executor-CAr7xQr2.js";
 import { d as contextProvenance, f as instructionActors, m as sameActorIdentity, p as instructionProvenanceFor, t as KNOWN_CONVERSATION_EVENT_TYPES, u as agentInstructionProvenance } from "./history-AY8rs-FR.js";
 import { a as listReferenceFiles, c as soulPathCandidates, l as worldPathCandidates } from "./package-discovery-DJBompdd.js";
-import { c as fetchWithBoundedOAuthErrorBodies, d as actorLogContext, f as credentialContextForActor, g as credentialUserSubjectId, i as resolvePluginHeaderEnvRefs, l as getOAuthProviderErrorAttributes, s as OAuthProviderError } from "./registry-BFzQFV_y.js";
-import { n as pluginCatalogRuntime } from "./catalog-runtime-Suf-aLlh.js";
-import { a as parseSkillInvocation, i as parseSkillFile, n as findSkillByName, r as loadSkillsByName, t as discoverSkills } from "./skills-Dbzx9-rS.js";
-import { A as getWorkspaceSnapshotBuilder, B as STOP_WATCHING_TOOL_NAME, C as WorkspaceValidationError, D as setWorkspaceSnapshotBuild, E as setWorkspaceSnapshot, F as isSlackMessageTurn, G as createWatch, Gt as saveObjectAnnotations, H as cancelWatch, I as slackMessageTurnDisabledReason, J as getWatch, K as deliverWatch, Kt as createPluginAnnotations, L as RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS, M as workspaceRepoCheckoutPath, N as resolveChannelCapabilities, O as SANDBOX_RUNTIME, P as getSlackToolContext, R as RESOURCE_SUBSCRIPTION_MAX_TTL_MS, S as updateWorkspace, St as PluginToolDeniedError, T as loadSnapshotsForProfile, V as cancelSubscriptions, Vt as matchSlackAttachments, W as createTimerWatch, Xt as resolveUserTimezone, Y as listWatches, Yt as defaultTimezone, _ as deleteWorkspace, _t as getDashboardConversationLink, at as downloadPrivateSlackFile, b as listWorkspaces, c as getPluginTools, ct as getSlackClient, dt as normalizeSlackConversationId, en as JUNIOR_NATIVE_EVENT_NAMESPACE, g as createWorkspace, in as conversationNoteEvent, it as SlackActionError, j as tryWorkspaceRepoCheckoutPath, k as deleteWorkspaceSnapshotBuilders, l as getPluginUserPromptContributions, lt as isConversationScopedChannel, ot as getFilePermalink, pt as withSlackRetries, q as findMatchingWatches, r as createPluginHookRunner, s as getPluginSystemPromptContributions, u as getPlugins, ut as isDmChannel$1, v as getWorkspace, w as invalidateReadySnapshot, xt as ToolInputError, y as getWorkspaceByName, yt as getDashboardTaskLink, z as RESOURCE_WATCH_TOOL_SOURCE } from "./agent-hooks-CqnZfuCt.js";
-import { o as fenceLock, r as getStateAdapter, s as withLock } from "./adapter-BIacI0Bt.js";
+import { c as fetchWithBoundedOAuthErrorBodies, d as actorLogContext, f as credentialContextForActor, g as credentialUserSubjectId, i as resolvePluginHeaderEnvRefs, l as getOAuthProviderErrorAttributes, s as OAuthProviderError } from "./registry-COTeZ2cV.js";
+import { n as pluginCatalogRuntime } from "./catalog-runtime-D3qbJlYz.js";
+import { a as parseSkillInvocation, i as parseSkillFile, n as findSkillByName, r as loadSkillsByName, t as discoverSkills } from "./skills-Bb2KaJ3m.js";
+import { $n as defaultTimezone, A as setWorkspaceSnapshotBuild, At as RESOURCE_SUBSCRIPTION_MAX_TTL_MS, B as wrapSandboxSetupError, Bt as getWatch, C as listWorkspaces, Cn as SANDBOX_WORKSPACE_ROOT, Ct as tryWorkspaceRepoCheckoutPath, D as invalidateReadySnapshot, Dt as isSlackMessageTurn, E as WorkspaceValidationError, En as sandboxSkillPathResolution, Et as getSlackToolContext, F as ensureDockerDaemon, Gn as matchSlackAttachments, H as getWorkspaceSnapshotNotReadyError, I as getSandboxProvider, It as createTimerWatch, J as consumeSandboxEgressAuthRequiredSignal, L as isAbortError, Lt as createWatch, M as create, Mt as STOP_WATCHING_TOOL_NAME, N as hash, Nt as cancelSubscriptions, O as loadSnapshotsForProfile, Ot as slackMessageTurnDisabledReason, P as isStale, Pt as cancelWatch, Qt as getFilePermalink, R as isAlreadyExistsError, Rt as deliverWatch, S as getWorkspaceByName, Sn as SANDBOX_SKILLS_ROOT, T as updateWorkspace, Tn as sandboxSkillFile, Tt as resolveChannelCapabilities, U as isWorkspaceSnapshotNotReadyError, V as WorkspaceSnapshotNotReadyError, Vt as listWatches, W as workspaceSnapshotNotReadyUserMessage, X as createSandboxEgressCredentialToken, Xn as createPluginAnnotations, Xt as SlackActionError, Y as consumeSandboxEgressPermissionDeniedSignal, Yn as saveObjectAnnotations, Zt as downloadPrivateSlackFile, _n as buildNonInteractiveShellScript, _t as openSlackDirectMessage, an as withSlackRetries, at as formatProviderLabel, b as deleteWorkspace, bn as SANDBOX_DATA_ROOT, bt as uploadFilesToConversation, cr as conversationNoteEvent, d as getPluginTools, en as getSlackClient, er as resolveUserTimezone, et as buildSandboxEgressNetworkPolicy, f as getPluginUserPromptContributions, fn as getDashboardTaskLink, gn as buildCommandScript, gt as getSlackMessagePermalink, hn as PluginToolDeniedError, ht as addReactionToMessage, ir as JUNIOR_NATIVE_EVENT_NAMESPACE, it as deliverOAuthAuthorization, j as SANDBOX_RUNTIME, jt as RESOURCE_WATCH_TOOL_SOURCE, k as setWorkspaceSnapshot, kt as RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS, mn as ToolInputError, n as createUserTokenStore, o as createPluginHookRunner, on as sleep, p as getPlugins, pt as slackMention, q as clearSandboxEgressSignals, r as getOAuthAccountProviders, rn as normalizeSlackConversationId, st as resolveBaseUrl, tn as isConversationScopedChannel, tt as resolveSandboxCommandEnvironment, u as getPluginSystemPromptContributions, un as getDashboardConversationLink, vn as runNonInteractiveCommand, wn as sandboxSkillDir, wt as workspaceRepoCheckoutPath, x as getWorkspace, xn as SANDBOX_REPOS_ROOT, y as createWorkspace, yn as SANDBOX_COMMAND_PATH, z as throwSandboxOperationError, zt as findMatchingWatches } from "./credentialed-C6pKlB1p.js";
+import { o as fenceLock, r as getStateAdapter, s as withLock } from "./adapter-cUkPH3Om.js";
 import { i as isValidTimeZone, r as getZonedDateTimeParts } from "./cadence-R7Em4RjE.js";
 import { G as briefLinkSchema, H as detectImageMediaType, I as removedCardSchema, K as briefOutcomeStatusSchema, U as isVisionImageMediaType, q as conversationBriefSchema } from "./conversation-B0baEwoA.js";
-import { A as sandboxSkillPathResolution, C as SANDBOX_COMMAND_PATH, D as SANDBOX_WORKSPACE_ROOT, E as SANDBOX_SKILLS_ROOT, O as sandboxSkillDir, S as runNonInteractiveCommand, T as SANDBOX_REPOS_ROOT, _ as workspaceSnapshotNotReadyUserMessage, a as isAbortError, b as buildCommandScript, c as isSandboxCommandStreamInterruptedError, d as isSnapshottingError, f as throwSandboxOperationError, g as isWorkspaceSnapshotNotReadyError, h as getWorkspaceSnapshotNotReadyError, i as ensureDockerDaemon, k as sandboxSkillFile, 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 SANDBOX_DATA_ROOT, x as buildNonInteractiveShellScript, y as sleep } from "./profile-Dq5I7TV1.js";
-import { A as AgentMessageQueueFullError, F as agentNameSchema, H as TurnInputCommitLostError, I as AGENT_TYPES, K as isTurnInputCommitLostError, M as AgentNameInUseError, N as CHILD_AGENT_RESULTS, P as PARENT_AGENT_TARGET, V as CooperativeTurnYieldError, _ as getLatestAgentInvocationForConversation, d as getAgentInvocationIdForResult, f as getAgentInvocationMessageId, g as getChildAgentLockName, j as AgentMessageTargetError, k as AgentInvocationLimitError, t as NON_TERMINAL_AGENT_INVOCATION_STATUSES, v as invocationFromRow, y as isTerminalAgentInvocation, z as formatAgentTypes } from "./store-TKg1HVKx.js";
-import { a as isNoReplyMarker, i as NO_REPLY_MARKER, n as getAssistantReplyText, r as sanitizeAssistantText, t as decideReply } from "./assistant-reply-BFmjgJjD.js";
-import { A as requireSupportedEventMatch, B as readAutomationResult, C as eventNamespaceSchema, D as registeredEventTypeSchema, E as registeredEventMatchSchema, I as FINISH_AUTOMATION_RUN_TOOL_NAME, L as automationResultSchema, O as registeredResourceTypeSchema, T as pluginSupportsEvent, V as remindMissingAutomationResult, _ as WORKSPACE_SNAPSHOT_FAILED_EVENT, b as workspaceSnapshotWatch, d as getEventCatalog, k as requireEventIdentifier, n as markConversationsStopped, o as enqueueEventNotification, p as requireSlackChannelMessageScope, t as getConversationStoppedAtMs, v as WORKSPACE_SNAPSHOT_READY_EVENT, w as hasEventCatalogEntries, x as automationEventCatalog, y as workspaceSnapshotFinishedEvent } from "./session-stop-CtyJsnEj.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-CnRHib0U.js";
-import { a as getVercelConversationWorkQueue, f as getTurnRequestDeadline, n as sendNextWorkspaceSnapshotJob, r as sendWorkspaceSnapshotJob } from "./job-queue-B4yTgklN.js";
-import { E as stopConversationWork } from "./store-UlOrW6JC.js";
-import { _ as getMcpProviderErrorAttributes, a as serviceAccountOnly, c as createMcpServiceAccountClientProvider, d as PluginMcpClient, f as McpProviderError, g as getMcpAwareTelemetryMessage, h as getMcpAwareErrorType, i as serviceAccountAllows, l as getMcpServiceAccountCredentials, m as McpToolError, p as McpServiceAccountRequiredError, u as McpAuthorizationRequiredError, v as toMcpProviderError } from "./service-account-x2QZXm4X.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-CWX0qL8U.js";
+import { A as AgentMessageQueueFullError, F as agentNameSchema, H as TurnInputCommitLostError, I as AGENT_TYPES, K as isTurnInputCommitLostError, M as AgentNameInUseError, N as CHILD_AGENT_RESULTS, P as PARENT_AGENT_TARGET, V as CooperativeTurnYieldError, _ as getLatestAgentInvocationForConversation, d as getAgentInvocationIdForResult, f as getAgentInvocationMessageId, g as getChildAgentLockName, j as AgentMessageTargetError, k as AgentInvocationLimitError, t as NON_TERMINAL_AGENT_INVOCATION_STATUSES, v as invocationFromRow, y as isTerminalAgentInvocation, z as formatAgentTypes } from "./store-CqRnaZSq.js";
+import { a as isNoReplyMarker, i as NO_REPLY_MARKER, n as getAssistantReplyText, r as sanitizeAssistantText, t as decideReply } from "./assistant-reply-UPA8vKlC.js";
+import { A as requireEventIdentifier, D as registeredEventMatchSchema, E as hasEventCatalogEntries, H as remindMissingAutomationResult, L as FINISH_AUTOMATION_RUN_TOOL_NAME, O as registeredEventTypeSchema, R as automationResultSchema, S as describeRegisteredEventTrigger, T as eventWatchUnavailable, V as readAutomationResult, _ as WORKSPACE_SNAPSHOT_FAILED_EVENT, b as workspaceSnapshotWatch, d as getEventCatalog, j as requireValidEventTrigger, k as registeredResourceTypeSchema, n as markConversationsStopped, o as enqueueEventNotification, p as requireSlackChannelMessageScope, t as getConversationStoppedAtMs, v as WORKSPACE_SNAPSHOT_READY_EVENT, w as eventNamespaceSchema, x as automationEventCatalog, y as workspaceSnapshotFinishedEvent } from "./session-stop-CpCUy1ZJ.js";
+import { a as setSnapshotSpanAttributes, i as postinstall, n as resolve$1, r as dependencies, s as getSandboxResources } from "./resolve-g9PKz9pH.js";
+import { a as getVercelConversationWorkQueue, f as getTurnRequestDeadline, n as sendNextWorkspaceSnapshotJob, r as sendWorkspaceSnapshotJob } from "./job-queue-Cjo6Yg_b.js";
+import { E as stopConversationWork } from "./store-DdT74Lvq.js";
+import { _ as getMcpProviderErrorAttributes, a as serviceAccountOnly, c as createMcpServiceAccountClientProvider, d as PluginMcpClient, f as McpProviderError, g as getMcpAwareTelemetryMessage, h as getMcpAwareErrorType, i as serviceAccountAllows, l as getMcpServiceAccountCredentials, m as McpToolError, p as McpServiceAccountRequiredError, u as McpAuthorizationRequiredError, v as toMcpProviderError } from "./service-account-YdYftwV2.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-2RbKzpMT.js";
 import { n as privateTraceResultAttributes } from "./private-trace-result-CE7_lEdq.js";
 import { streamSimple } from "@earendil-works/pi-ai/compat";
 import { createGatewayProvider } from "@ai-sdk/gateway";
@@ -36,13 +35,13 @@ import { isDeepStrictEqual } from "node:util";
 import { z } from "zod";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { and, asc, desc, eq, gt, gte, inArray, isNotNull, isNull, lt, lte, ne, notExists, or, sql } from "drizzle-orm";
-import { PluginToolInputError, eventSchema, missingToolAnnotationKeys, ownedObjectAnnotationSchema, sourceSchema, stableEventMatchKey, watchResultSchema } from "@sentry/junior-plugin-api";
+import { PluginToolInputError, eventMatchFieldSchema, eventSchema, eventTriggerText, missingToolAnnotationKeys, ownedObjectAnnotationSchema, 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";
 import fs$1 from "node:fs";
-import { Sandbox } from "@vercel/sandbox";
-import { isRetryableAssistantError } from "@earendil-works/pi-ai";
+import { SignJWT, importPKCS8 } from "jose";
+import { createAssistantMessageEventStream, isRetryableAssistantError } from "@earendil-works/pi-ai";
 import { Kind } from "@sinclair/typebox";
 import { Bash, defineCommand } from "just-bash";
 import { structuredPatch } from "diff";
@@ -53,7 +52,6 @@ import https from "node:https";
 import net from "node:net";
 import { NodeHtmlMarkdown } from "node-html-markdown";
 import { Value } from "@sinclair/typebox/value";
-import { SignJWT, importPKCS8 } from "jose";
 // src/chat/sandbox/skill-sandbox.ts
 const MAX_SKILL_FILE_BYTES = 262144;
 const DEFAULT_MAX_SKILL_FILE_CHARS = 2e4;
@@ -716,6 +714,53 @@ function buildChatEndAttributes(message, mode) {
 	}
 	return attributes;
 }
+const NON_CONTENT_EVENT_TYPES = /* @__PURE__ */ new Set([
+	"start",
+	"done",
+	"error"
+]);
+function createResponseTiming(requestStartedAtMs) {
+	let firstByteAtMs;
+	let firstToken;
+	return {
+		observe: (event) => {
+			if (firstByteAtMs === void 0 && event.type !== "error") firstByteAtMs = Date.now();
+			if (!firstToken && !NON_CONTENT_EVENT_TYPES.has(event.type)) firstToken = {
+				type: event.type,
+				receivedAtMs: Date.now()
+			};
+		},
+		attributes: () => {
+			if (firstByteAtMs === void 0) return { "gen_ai.response.streaming": false };
+			return {
+				"gen_ai.response.streaming": true,
+				"app.ai.time_to_first_byte_ms": firstByteAtMs - requestStartedAtMs,
+				...firstToken ? {
+					"gen_ai.response.time_to_first_chunk": (firstToken.receivedAtMs - requestStartedAtMs) / 1e3,
+					"app.ai.first_token_type": firstToken.type
+				} : void 0
+			};
+		}
+	};
+}
+function relayStream(source, onEvent) {
+	const relayed = createAssistantMessageEventStream();
+	const finished = (async () => {
+		try {
+			for await (const event of source) {
+				onEvent(event);
+				relayed.push(event);
+			}
+		} finally {
+			relayed.end();
+		}
+	})();
+	finished.then(() => source.result()).then((message) => relayed.end(message), () => {});
+	return {
+		stream: relayed,
+		finished
+	};
+}
 /**
 * Wraps pi-ai's `streamSimple` so each LLM call inside a pi-agent-core agent
 * loop produces its own `gen_ai.chat` Sentry span. The returned function is
@@ -737,10 +782,16 @@ function createTracedStreamFn(baseOrOptions = streamSimple) {
 			}
 		});
 		try {
+			const requestStartedAtMs = Date.now();
 			const stream = await withActiveSpan(span, () => Promise.resolve(base(model, context, options)));
-			stream.result().then((finalMessage) => {
+			const responseTiming = createResponseTiming(requestStartedAtMs);
+			const relay = relayStream(stream, responseTiming.observe);
+			relay.finished.then(() => stream.result()).then((finalMessage) => {
 				try {
-					const endAttributes = buildChatEndAttributes(finalMessage, mode);
+					const endAttributes = {
+						...buildChatEndAttributes(finalMessage, mode),
+						...responseTiming.attributes()
+					};
 					for (const [key, value] of Object.entries(endAttributes)) span.setAttribute(key, value);
 					if (finalMessage.stopReason === "error") {
 						const summary = endAttributes["app.ai.provider_error.summary"];
@@ -753,6 +804,7 @@ function createTracedStreamFn(baseOrOptions = streamSimple) {
 					span.end();
 				}
 			}, (error) => {
+				span.setAttributes(responseTiming.attributes());
 				span.setAttribute("error.type", error instanceof Error ? error.name : typeof error);
 				span.setStatus({
 					code: 2,
@@ -760,7 +812,7 @@ function createTracedStreamFn(baseOrOptions = streamSimple) {
 				});
 				span.end();
 			}).catch(() => {});
-			return stream;
+			return relay.stream;
 		} catch (error) {
 			span.setAttribute("error.type", error instanceof Error ? error.name : typeof error);
 			span.setStatus({
@@ -1664,7 +1716,7 @@ function formatAvailableSkillsForPrompt(skills) {
 }
 function formatActiveMcpCatalogsForPrompt(catalogs) {
 	if (catalogs.length === 0) return null;
-	const lines = ["Active MCP provider catalogs are available through `searchMcpTools`. Call it with provider to list descriptors or with query to narrow results, then pass the exact returned `tool_name` to `callMcpTool`. Put provider fields inside `arguments`."];
+	const lines = [];
 	for (const catalog of catalogs) {
 		lines.push("  <catalog>");
 		lines.push(`    <provider>${escapeXml(catalog.provider)}</provider>`);
@@ -1702,31 +1754,22 @@ const SLACK_HEADER = "You are a Slack-based helper assistant. Follow the persona
 const LOCAL_HEADER = "You are a helper assistant. Follow the personality section for voice and tone in every reply. Platform mechanics and output rules override personality and world context when they conflict.";
 const TURN_CONTEXT_HEADER = "Runtime context for this request. Treat these blocks as trusted runtime facts; the static system prompt remains authoritative.";
 const TOOL_POLICY_RULES = [
-	"- Tool schemas are the source of truth for parameters; tool names are case-sensitive, so call tools exactly by their exposed names and do not invent arguments.",
 	"- Use tools for actionable work and for facts that are mutable, external, repository-backed, provider-backed, or requested as verified/current. Stable general knowledge and already-provided context may be answered directly.",
 	"- Do not use tools to rediscover content already present in the current conversation. For drafting or rewriting with no referenced retrievable source, use clear placeholders or ask one focused question instead of searching unrelated memory, history, files, or providers.",
 	"- Resolve provider action targets before calls: explicit target wins; ambient `<configuration>` fills omitted targets. Treat non-target links/references as context.",
 	"- Verification source order: conversation/thread context; user-provided attachments, links, and reference files; local/sandbox files when present; loaded skill references; repository/provider tools; public web. Use the nearest authoritative available source before weaker sources.",
 	"- For repository or implementation questions, inspect the target repository first: local checkout when present, otherwise the configured GitHub/source provider. Do not treat loaded skill files as repo source unless the user asks about the skill. Cite file paths, symbols, PRs/issues, commits, or URLs that support the answer.",
-	"- Workspaces are named prepared Sandbox recipes. Use `listWorkspaces` and `switchWorkspace` with them. Prefer a matching Workspace over an ad-hoc checkout when one fits.",
 	"- After changing files, name the changed paths and summarize the completed result in the final answer.",
-	"- If a sandbox-backed tool reports that sandbox execution is unavailable, treat that as a blocker for local file/shell inspection; do not pretend host files were inspected.",
-	"- 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.",
 	"- 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.",
-	"- Scheduled and event automations use their creator's connected credentials by default when the requested work needs them. Do not ask for separate confirmation merely to use those credentials. On creation, omit credentialMode for this default; set system only when the creator requires it. For updates, creator means the original createdBy actor, not the current requester. Only that creator may enable creator credential use; another requester's confirmation cannot 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.",
-	"- Before loading a skill or starting substantial work, decide how to run it. When `handoff` is available and another profile fits better, switch first. When `spawnAgent` is available and its delegation rules fit, give independent tracks to child agents. Otherwise do the work inline.",
-	"- Run `jr-rpc config get|set|unset|list` for provider defaults and `jr-rpc plugins list` for installed plugin introspection as standalone bash commands; do not chain them with `cd`, `&&`, pipes, or provider commands.",
+	"- Scheduled and event automations use their creator's connected credentials by default when the requested work needs them. Do not ask for separate confirmation merely to use those credentials.",
+	"- Before loading a skill or starting substantial work, decide whether `handoff` or `spawnAgent` fits better than inline work.",
 	"- If the first result is empty, stale, ambiguous, or incomplete, try a focused alternate query, path, command, or source before concluding the answer cannot be verified."
 ];
 const TOOL_CALL_STYLE_RULES = [
 	"- For routine low-risk tool use, call the tool directly without narrating the obvious step first.",
 	"- Briefly narrate only when it helps the user understand multi-step work, sensitive actions, destructive actions, or a notable change in approach.",
-	"- When a first-class tool exists for an action, use it directly instead of asking the user to run an equivalent command, slash command, or manual lookup.",
-	"- Keep tool-call explanations separate from final answers; final answers should report results, evidence, or blockers."
+	"- When a first-class tool exists for an action, use it directly instead of asking the user to run an equivalent command, slash command, or manual lookup."
 ];
 const SKILL_POLICY_RULES = [
 	"- A `<skill>` block in the current user turn is already loaded. Follow its instructions directly and do not call `loadSkill` for that skill.",
@@ -1739,9 +1782,8 @@ const PLANNING_RULES = [
 	"- The tool displays the plan. Do not repeat it in chat, and do not finish with a plan when you can complete the work now."
 ];
 const TASK_EXECUTION_RULES = [
-	"- Actionable request: act in this turn.",
 	"- Continue until done, genuinely blocked, or waiting on child agents you started. Do not finish with a plan, promise, or offer to check next when an available tool or source can move the request forward.",
-	"- Ask the user only for missing access, approval, or a decision that blocks safe progress. Ask one focused question; otherwise infer conservatively and continue.",
+	"- Ask the user only for missing access or a decision that blocks safe progress. Ask one focused question; otherwise infer conservatively and continue. An open scope or follow-up question does not block delivery: deliver the requested work and state the question.",
 	"- For conflicting evidence, compare sources and state which source is authoritative for the answer.",
 	"- A tool result with `timed_out: true` means that attempt did not finish. Continue the active task. Before retrying work that may have side effects, inspect authoritative state and do not repeat a mutation that already applied."
 ];
@@ -1753,8 +1795,7 @@ const CONVERSATION_RULES = [
 	"- Runtime owns continuation and authorization notices; on resumed turns, answer with the final requested content only."
 ];
 const SLACK_ACTION_RULES = [
-	"- Slack posts, reactions, new canvases, new lists, and file sends go only to the current conversation; if asked to send one somewhere else, explain the limitation instead of calling the tool. Slack read tools can target other public channels with `channel_id`.",
-	"- Assistant text is delivered only into the active conversation or thread. You cannot create a new top-level channel post; if asked to do so, explain that limitation and do not present the requested text as delivered.",
+	"- Assistant text, Slack posts, reactions, new canvases, new lists, and file sends go only to the current conversation or thread. Your reply is not a channel post, and you cannot create a new top-level channel post. When asked to post to a channel or anywhere else right now, explain that limitation; do not call a Slack send tool, and do not reply with only the requested text or present it as delivered. Scheduled automations can still post to the active channel later. Slack read tools can target other public channels with `channel_id`.",
 	"- 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}.`
 ];
@@ -1898,22 +1939,12 @@ 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",
-		...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.declaresResult ? [] : ["- 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),
@@ -2718,24 +2749,38 @@ function createJrRpcCommand(deps) {
 		});
 	});
 }
+function toolCommandResult(command, output) {
+	return {
+		ok: output.exitCode === 0,
+		command,
+		cwd: "/",
+		exit_code: output.exitCode,
+		signal: null,
+		timed_out: false,
+		stdout: output.stdout,
+		stderr: output.stderr,
+		stdout_truncated: false,
+		stderr_truncated: false
+	};
+}
+const CHAINED_JR_RPC_PATTERN = /(?:&&|\|\||[;|\n])\s*jr-rpc(?:\s|$)/;
+/** Run a standalone `jr-rpc` bash command, or reject one chained after other shell steps. */
 async function maybeExecuteJrRpcCustomCommand(command, deps) {
 	const normalized = command.trim();
-	if (!/^jr-rpc(?:\s|$)/.test(normalized)) return { handled: false };
-	const execResult = await new Bash({ customCommands: [createJrRpcCommand(deps)] }).exec(normalized);
+	if (!/^jr-rpc(?:\s|$)/.test(normalized)) {
+		if (!CHAINED_JR_RPC_PATTERN.test(normalized)) return { handled: false };
+		return {
+			handled: true,
+			result: toolCommandResult(normalized, {
+				exitCode: 2,
+				stdout: "",
+				stderr: "jr-rpc runs only as a standalone bash command. Run the jr-rpc command by itself, without cd, &&, pipes, or other commands.\n"
+			})
+		};
+	}
 	return {
 		handled: true,
-		result: {
-			ok: execResult.exitCode === 0,
-			command: normalized,
-			cwd: "/",
-			exit_code: execResult.exitCode,
-			signal: null,
-			timed_out: false,
-			stdout: execResult.stdout,
-			stderr: execResult.stderr,
-			stdout_truncated: false,
-			stderr_truncated: false
-		}
+		result: toolCommandResult(normalized, await new Bash({ customCommands: [createJrRpcCommand(deps)] }).exec(normalized))
 	};
 }
 // src/chat/sandbox/command-result.ts
@@ -2960,9 +3005,9 @@ const BUILD_COMMAND_TIMEOUT_ERROR = "Workspace snapshot build phase timed out af
 const COMMAND_STATUS_POLL_TIMEOUT_MS = 1e3;
 /** Leave time to save the build state before this request ends. */
 const STOP_BUFFER_MS = 4e4;
-/** Keep the build open when a request stops or Vercel has a short failure. */
+/** Keep the build open when a request stops or the provider has a short failure. */
 function isCancelOrTransient(error) {
-	return isAbortError(error) || isSandboxApiTransientError(error);
+	return isAbortError(error) || getSandboxProvider().errors.isTransient(error);
 }
 function buildLockKey(profileHash) {
 	return `${BUILD_LOCK_PREFIX}:${profileHash}`;
@@ -3003,7 +3048,7 @@ function activeBuild(build) {
 }
 async function deleteBuilder(sandboxName) {
 	if (!sandboxName) return;
-	await deleteWorkspaceSnapshotBuilders([sandboxName]);
+	await getSandboxProvider().deleteWorkspaceSnapshotBuilders([sandboxName]);
 }
 function workspaceDeletedError(workspace) {
 	return /* @__PURE__ */ new Error(`Workspace ${workspace.name} was deleted while its snapshot was building`);
@@ -3044,8 +3089,8 @@ async function finishBuild(workspace, value, signal, beforeWrite) {
 	if (!build?.commandId || !build.sandboxName) return null;
 	try {
 		await requireRemainingBuildTime(workspace, build, beforeWrite);
-		const sandbox = await getWorkspaceSnapshotBuilder(build.sandboxName, signal);
-		const command = await sandbox.getCommand(build.commandId, { signal });
+		const builder = await getSandboxProvider().getWorkspaceSnapshotBuilder(build.sandboxName, signal);
+		const command = await builder.getCommand(build.commandId, { signal });
 		const pollSignal = AbortSignal.timeout(COMMAND_STATUS_POLL_TIMEOUT_MS);
 		const waitSignal = signal ? AbortSignal.any([signal, pollSignal]) : pollSignal;
 		let finished;
@@ -3065,7 +3110,7 @@ async function finishBuild(workspace, value, signal, beforeWrite) {
 			throw new Error(`Workspace ${workspace.name} snapshot setup failed: ${detail}`);
 		}
 		await requireRemainingBuildTime(workspace, build, beforeWrite);
-		const snapshot = await sandbox.snapshot({ signal });
+		const snapshot = await builder.snapshot({ signal });
 		await requireRemainingBuildTime(workspace, build, beforeWrite);
 		const createdAtMs = Date.now();
 		const buildDurationMs = Math.max(0, createdAtMs - build.startedAt.getTime());
@@ -3080,7 +3125,7 @@ async function finishBuild(workspace, value, signal, beforeWrite) {
 		}, { buildId: build.id });
 		requireBuildWrite(result.written, workspace);
 		try {
-			await deleteWorkspaceSnapshotBuilders(result.replacedBuilderNames);
+			await getSandboxProvider().deleteWorkspaceSnapshotBuilders(result.replacedBuilderNames);
 		} catch (error) {
 			logException(error, "sandbox.workspace_snapshot.builder.delete_failed", {
 				"app.workspace.id": workspace.id,
@@ -3107,19 +3152,16 @@ async function finishBuild(workspace, value, signal, beforeWrite) {
 /** Create the Sandbox and save its name. */
 async function startBuild(params) {
 	const { workspace, value, signal } = params;
-	const credentials = getVercelSandboxCredentials();
 	const resources = getSandboxResources(workspace);
 	const name = builderName();
 	const buildId = randomUUID();
 	const startedAt = /* @__PURE__ */ new Date();
 	try {
-		await Sandbox.create({
+		await getSandboxProvider().createWorkspaceSnapshotBuilder({
 			name,
-			persistent: true,
-			timeout: BUILD_TIMEOUT_MS,
 			runtime: params.runtime,
+			timeoutMs: BUILD_TIMEOUT_MS,
 			signal,
-			...credentials ?? {},
 			...resources ? { resources } : void 0
 		});
 		await params.beforeWrite();
@@ -3181,8 +3223,8 @@ async function continueBuild(params) {
 	const phaseTimeoutSignal = AbortSignal.timeout(commandTimeoutMs);
 	const phaseSignal = params.signal ? AbortSignal.any([params.signal, phaseTimeoutSignal]) : phaseTimeoutSignal;
 	try {
-		const sandbox = await getWorkspaceSnapshotBuilder(build.sandboxName, phaseSignal);
-		const session = createSandboxSession(sandbox);
+		const builder = await getSandboxProvider().getWorkspaceSnapshotBuilder(build.sandboxName, phaseSignal);
+		const session = builder.session();
 		if (build.phase === "created") {
 			await dependencies(session, params.value.dependencies, phaseSignal, commandTimeoutMs);
 			await postinstall(session, params.value.postinstall, phaseSignal, commandTimeoutMs);
@@ -3212,16 +3254,15 @@ async function continueBuild(params) {
 			return;
 		}
 		await params.beforeWrite();
-		const command = await sandbox.runCommand({
+		const commandId = await builder.startDetachedCommand({
 			...workspaceSnapshotSetupCommand(params.workspace, build.id),
-			detached: true,
 			timeoutMs: remainingMs,
 			signal: phaseSignal
 		});
 		await params.beforeWrite();
 		requireBuildWrite(await setWorkspaceSnapshotBuild(params.workspace.id, {
 			...build,
-			commandId: command.cmdId,
+			commandId,
 			error: null
 		}), params.workspace);
 	} catch (error) {
@@ -3318,7 +3359,7 @@ async function resolveWorkspaceSnapshot(params) {
 		try {
 			snapshot = await advanceWorkspaceSnapshot(current);
 		} catch (error) {
-			if (!isSandboxApiTransientError(error)) throw error;
+			if (!getSandboxProvider().errors.isTransient(error)) throw error;
 			advanced = true;
 			if (shouldStopForTimeLimit(current.shouldStop)) throw new WorkspaceSnapshotNotReadyError(workspace.name);
 			await sleep(TRANSIENT_API_RETRY_MS, params.signal);
@@ -3583,6 +3624,42 @@ async function syncSkillsToSandbox(params) {
 		});
 	});
 }
+// src/chat/sandbox/workspace.ts
+/** Bind one tool call's cancellation to every sandbox filesystem operation. */
+function bindSandboxFileSystem(fs, signal) {
+	if (!signal) return fs;
+	return {
+		readFile(filePath, options) {
+			signal.throwIfAborted();
+			return fs.readFile(filePath, {
+				...options,
+				signal
+			});
+		},
+		writeFile(filePath, content, options) {
+			signal.throwIfAborted();
+			return fs.writeFile(filePath, content, {
+				...options,
+				signal
+			});
+		},
+		readdir(filePath) {
+			signal.throwIfAborted();
+			return fs.readdir(filePath, { signal });
+		},
+		stat(filePath) {
+			signal.throwIfAborted();
+			return fs.stat(filePath, { signal });
+		}
+	};
+}
+/** Best-effort stop; ignore secondary stop failures during cleanup. */
+async function stopSession(session) {
+	if (!session) return;
+	try {
+		await session.stop();
+	} catch {}
+}
 // src/chat/sandbox/session.ts
 const DEFAULT_MAX_OUTPUT_LENGTH = 3e4;
 const DEFAULT_BASH_COMMAND_TIMEOUT_MS = 3e5;
@@ -3591,16 +3668,6 @@ const SNAPSHOT_BOOT_RETRY_DELAY_MS = 1e3;
 const SANDBOX_NAME_PREFIX = "junior-";
 const MAX_KEEPALIVE_INTERVAL_MS = 3e4;
 const MIN_KEEPALIVE_INTERVAL_MS = 1e3;
-function sandboxFetchOptions(signal) {
-	if (!signal) return {};
-	return { fetch: (input, init) => {
-		const requestSignal = init?.signal ?? (input instanceof Request ? input.signal : void 0);
-		return globalThis.fetch(input, {
-			...init,
-			signal: requestSignal ? AbortSignal.any([requestSignal, signal]) : signal
-		});
-	} };
-}
 function truncateOutput(output, maxLength) {
 	if (output.length <= maxLength) return {
 		value: output,
@@ -3650,7 +3717,10 @@ function createSandboxRuntime(options) {
 			keepAliveTimer = void 0;
 		}
 	};
-	const adaptSandbox = (vercelSandbox) => createSandboxSession(vercelSandbox, { onUnavailable: invalidateSession });
+	const createSession = (input) => getSandboxProvider().createSession({
+		...input,
+		onUnavailable: invalidateSession
+	});
 	const createSandboxName = () => `${SANDBOX_NAME_PREFIX}${randomUUID()}`;
 	const preflightNetworkPolicy = (sandboxName) => options.createNetworkPolicy?.(sandboxName);
 	const persistSandboxRef = async (nextRef) => {
@@ -3717,30 +3787,26 @@ function createSandboxRuntime(options) {
 			}
 		});
 	};
-	const createSandboxFromSnapshot = async (snapshotId, sandboxCredentials, initialSandboxName, workspace, signal) => {
+	const createSandboxFromSnapshot = async (snapshotId, initialSandboxName, workspace, signal) => {
 		const resources = getSandboxResources(workspace);
 		for (let attempt = 0; attempt < SNAPSHOT_BOOT_RETRY_COUNT; attempt += 1) {
 			signal?.throwIfAborted();
 			const sandboxName = attempt === 0 ? initialSandboxName : createSandboxName();
 			const networkPolicy = preflightNetworkPolicy(sandboxName);
 			try {
-				return adaptSandbox(await Sandbox.create({
-					timeout: timeoutMs,
+				return await createSession({
+					timeoutMs,
 					...networkPolicy ? {
 						name: sandboxName,
 						persistent: false,
 						networkPolicy
 					} : void 0,
-					source: {
-						type: "snapshot",
-						snapshotId
-					},
+					snapshotId,
 					...resources ? { resources } : void 0,
-					...sandboxCredentials ?? {},
-					...sandboxFetchOptions(signal)
-				}));
+					scopeSignal: signal
+				});
 			} catch (error) {
-				if (!isSnapshottingError(error) || attempt === 2) throw error;
+				if (!getSandboxProvider().errors.isSnapshotting(error) || attempt === 2) throw error;
 				await sleep(SNAPSHOT_BOOT_RETRY_DELAY_MS, signal);
 			}
 		}
@@ -3756,14 +3822,14 @@ function createSandboxRuntime(options) {
 		}
 	};
 	const createSandboxFromResolvedSnapshot = async (params) => {
-		const { runtime, snapshot, sandboxCredentials, sandboxName, signal } = params;
+		const { runtime, snapshot, sandboxName, signal } = params;
 		signal?.throwIfAborted();
 		if (!snapshot.snapshotId) {
 			const networkPolicy = preflightNetworkPolicy(sandboxName);
 			const resources = getSandboxResources(params.workspace);
 			return {
-				session: adaptSandbox(await Sandbox.create({
-					timeout: timeoutMs,
+				session: await createSession({
+					timeoutMs,
 					runtime,
 					...networkPolicy ? {
 						name: sandboxName,
@@ -3771,19 +3837,18 @@ function createSandboxRuntime(options) {
 						networkPolicy
 					} : void 0,
 					...resources ? { resources } : void 0,
-					...sandboxCredentials ?? {},
-					...sandboxFetchOptions(signal)
-				})),
+					scopeSignal: signal
+				}),
 				snapshot
 			};
 		}
 		try {
 			return {
-				session: await createSandboxFromSnapshot(snapshot.snapshotId, sandboxCredentials, sandboxName, params.workspace, signal),
+				session: await createSandboxFromSnapshot(snapshot.snapshotId, sandboxName, params.workspace, signal),
 				snapshot
 			};
 		} catch (error) {
-			if (!isMissingError(error)) throw error;
+			if (!getSandboxProvider().errors.isSnapshotMissing(error)) throw error;
 			setSpanAttributes({ "app.sandbox.snapshot.rebuild_after_missing": true });
 			let rebuilt;
 			if (params.workspace) rebuilt = await requireWorkspaceSnapshot({
@@ -3802,14 +3867,13 @@ function createSandboxRuntime(options) {
 			if (!rebuilt.snapshotId) throw error;
 			signal?.throwIfAborted();
 			return {
-				session: await createSandboxFromSnapshot(rebuilt.snapshotId, sandboxCredentials, sandboxName, params.workspace, signal),
+				session: await createSandboxFromSnapshot(rebuilt.snapshotId, sandboxName, params.workspace, signal),
 				snapshot: rebuilt
 			};
 		}
 	};
 	const createSandboxCandidate = async (workspace, hash, signal) => {
 		const runtime = SANDBOX_RUNTIME;
-		const sandboxCredentials = getVercelSandboxCredentials();
 		const sandboxName = createSandboxName();
 		const prepareWorkspace = workspace ? async (sandbox) => await prepareWorkspaceSnapshot({
 			sandbox,
@@ -3840,7 +3904,6 @@ function createSandboxRuntime(options) {
 				return (await createSandboxFromResolvedSnapshot({
 					runtime,
 					snapshot,
-					sandboxCredentials,
 					sandboxName,
 					signal,
 					workspace,
@@ -3899,22 +3962,20 @@ function createSandboxRuntime(options) {
 		if (!ref) return null;
 		let hintedSandbox = null;
 		try {
-			const sandboxCredentials = getVercelSandboxCredentials();
 			hintedSandbox = await withSandboxSpan("sandbox.get", "sandbox.get", {
 				"app.sandbox.reused": true,
 				"app.sandbox.source": "id_hint"
-			}, async () => adaptSandbox(await Sandbox.get({
+			}, async () => await getSandboxProvider().getSession({
 				name: ref.id,
-				resume: true,
-				...sandboxCredentials ?? {},
-				...sandboxFetchOptions(signal)
-			})));
+				onUnavailable: invalidateSession,
+				scopeSignal: signal
+			}));
 		} catch (error) {
-			if (isSandboxMissingError(error)) {
+			if (getSandboxProvider().errors.isMissing(error)) {
 				sandboxRef = void 0;
 				return null;
 			}
-			if (isSandboxUnavailableError(error)) {
+			if (getSandboxProvider().errors.isUnavailable(error)) {
 				invalidateSession();
 				throw error;
 			}
@@ -3931,7 +3992,7 @@ function createSandboxRuntime(options) {
 			});
 			return rememberSandbox(hintedSandbox, networkPolicyKey);
 		} catch (error) {
-			if (isSandboxUnavailableError(error)) throw error;
+			if (getSandboxProvider().errors.isUnavailable(error)) throw error;
 			return failSetup(error);
 		}
 	};
@@ -3941,13 +4002,21 @@ function createSandboxRuntime(options) {
 			"app.sandbox.timeout_ms": timeoutMs,
 			"app.sandbox.runtime": SANDBOX_RUNTIME,
 			"app.sandbox.skills_count": availableSkills.length
-		}, async () => {
+		}, async (setSpanAttributes) => {
 			const cachedSandbox = await tryReuseCachedSandbox();
-			if (cachedSandbox) return cachedSandbox;
+			if (cachedSandbox) {
+				setSpanAttributes({ "app.sandbox.acquire.outcome": "memory" });
+				return cachedSandbox;
+			}
 			signal?.throwIfAborted();
 			const hintedSandbox = await tryRestoreHintedSandbox(signal);
-			if (hintedSandbox) return hintedSandbox;
-			return await createFreshSandbox(signal);
+			if (hintedSandbox) {
+				setSpanAttributes({ "app.sandbox.acquire.outcome": "resumed" });
+				return hintedSandbox;
+			}
+			const createdSandbox = await createFreshSandbox(signal);
+			setSpanAttributes({ "app.sandbox.acquire.outcome": "created" });
+			return createdSandbox;
 		});
 	};
 	const getOrAcquireSandbox = async (signal) => {
@@ -4017,7 +4086,7 @@ function createSandboxRuntime(options) {
 				await session.extendTimeout(keepAliveMs);
 			});
 		} catch (error) {
-			if (isSandboxUnavailableError(error)) throw error;
+			if (getSandboxProvider().errors.isUnavailable(error)) throw error;
 		}
 	};
 	const startKeepAlive = (session) => {
@@ -5172,27 +5241,21 @@ function createSandbox(options) {
 		const { bash: executeBash, sessionId: activeSessionId } = await runtime.tools(context.signal);
 		await clearEgressSignals(activeSessionId);
 		const result = await withSandboxToolSpan("bash", "process.exec", { "process.executable.name": "bash" }, async () => {
-			try {
-				const response = await executeBash({
-					command,
-					cwd,
-					...env ? { env } : void 0,
-					...timeoutMs ? { timeoutMs } : void 0,
-					...context.signal ? { signal: context.signal } : void 0
-				});
-				setSpanAttributes({
-					"process.exit.code": response.exitCode,
-					"app.sandbox.stdout_bytes": Buffer.byteLength(response.stdout ?? "", "utf8"),
-					"app.sandbox.stderr_bytes": Buffer.byteLength(response.stderr ?? "", "utf8"),
-					...response.aborted ? { "error.type": "outcome_unknown" } : response.exitCode !== 0 ? { "error.type": "nonzero_exit" } : {}
-				});
-				setSpanStatus(response.exitCode === 0 ? "ok" : "error");
-				return response;
-			} catch (error) {
-				setSpanAttributes({ "error.type": error instanceof Error ? error.name : "sandbox_execute_error" });
-				setSpanStatus("error");
-				throw error;
-			}
+			const response = await executeBash({
+				command,
+				cwd,
+				...env ? { env } : void 0,
+				...timeoutMs ? { timeoutMs } : void 0,
+				...context.signal ? { signal: context.signal } : void 0
+			});
+			setSpanAttributes({
+				"process.exit.code": response.exitCode,
+				"app.sandbox.stdout_bytes": Buffer.byteLength(response.stdout ?? "", "utf8"),
+				"app.sandbox.stderr_bytes": Buffer.byteLength(response.stderr ?? "", "utf8"),
+				...response.aborted ? { "error.type": "outcome_unknown" } : response.exitCode !== 0 ? { "error.type": "nonzero_exit" } : {}
+			});
+			setSpanStatus(response.exitCode === 0 ? "ok" : "error");
+			return response;
 		});
 		const { authRequired, permissionDenied } = await consumeEgressSignals(activeSessionId);
 		return formatSandboxCommandResult({
@@ -5386,8 +5449,8 @@ function createSandbox(options) {
 		} catch (error) {
 			params.signal?.throwIfAborted();
 			if (getWorkspaceSnapshotNotReadyError(error)) return createWorkspaceSnapshotNotReadyToolResult(error);
-			if (isSandboxUnavailableError(error)) throw createSandboxUnavailableToolError(params.toolName, error);
-			if (isSandboxCommandStreamInterruptedError(error)) throw new ToolInputError(`The sandbox command stream was interrupted during ${params.toolName}, so the operation did not complete reliably. It may have produced side effects; inspect the workspace or retry only if it is safe.`, { cause: error });
+			if (getSandboxProvider().errors.isUnavailable(error)) throw createSandboxUnavailableToolError(params.toolName, error);
+			if (getSandboxProvider().errors.isCommandStreamInterrupted(error)) throw new ToolInputError(`The sandbox command stream was interrupted during ${params.toolName}, so the operation did not complete reliably. It may have produced side effects; inspect the workspace or retry only if it is safe.`, { cause: error });
 			throw error;
 		}
 		throw new Error(`unsupported sandbox tool: ${params.toolName}`);
@@ -5398,7 +5461,7 @@ function createSandbox(options) {
 		} catch (error) {
 			const notReady = getWorkspaceSnapshotNotReadyError(error);
 			if (notReady) throw new ToolInputError(workspaceSnapshotNotReadyUserMessage(notReady), { cause: notReady });
-			if (isSandboxUnavailableError(error)) throw createSandboxUnavailableToolError(operation, error);
+			if (getSandboxProvider().errors.isUnavailable(error)) throw createSandboxUnavailableToolError(operation, error);
 			throw error;
 		}
 	};
@@ -5664,7 +5727,7 @@ function upstreamPermissionDeniedText(value) {
 		`Status: ${status}`,
 		...command ? [`Command: ${command}`] : [],
 		"",
-		"Junior had a credential lease for this grant and forwarded the request. Do not diagnose this as a missing user token or a local Junior runtime block.",
+		"The runtime had a credential lease for this grant and forwarded the request. Do not diagnose this as a missing user token or a local runtime block.",
 		"Read the provider's error in the command output before you choose a cause. A provider can reject a request because of permissions, installation scope, SSO, or account access. It can also reject a valid credential because of the target's state, a rate limit, or another provider rule.",
 		...stderr ? ["", `stderr:\n${stderr}`] : [],
 		...stdout ? ["", `stdout:\n${stdout}`] : []
@@ -6068,7 +6131,7 @@ var McpToolManager = class {
 	async clientForTool(plugin, client, toolName) {
 		const provider = plugin.manifest.name;
 		if (!this.serviceAccountProviders.has(provider) || serviceAccountAllows(plugin.manifest, { tool: toolName })) return client;
-		if (serviceAccountOnly(plugin.manifest)) throw new McpToolError(`${plugin.manifest.displayName} tool ${toolName} is not available: Junior's shared ${plugin.manifest.displayName} account cannot use it`);
+		if (serviceAccountOnly(plugin.manifest)) throw new McpToolError(`${plugin.manifest.displayName} tool ${toolName} is not available: the shared ${plugin.manifest.displayName} account cannot use it`);
 		const existing = this.actorClientsByProvider.get(provider);
 		if (existing) return existing;
 		const actorClient = await this.newClient(plugin);
@@ -6646,7 +6709,7 @@ function createLoadSkillTool(availableSkills, options) {
 			readOnlyHint: false
 		},
 		description: "Load a skill by name for this turn. The result includes working_directory; resolve skill paths there and run skill-owned bash commands from there or with absolute paths. When the skill instructions name an MCP provider, use searchMcpTools before callMcpTool. Use when a request clearly matches a known skill.",
-		inputSchema: z.object({ skill_name: z.string().min(1).describe("Skill name to load, without the leading slash.") }),
+		inputSchema: z.object({ skill_name: z.string().min(1).describe("Skill name to load, without the leading `$`.") }),
 		outputSchema: juniorToolOutputSchema,
 		execute: async ({ skill_name }) => {
 			const result = await loadSkillFromHost(availableSkills, skill_name);
@@ -6795,10 +6858,10 @@ function createSearchMcpToolsTool(mcpToolManager) {
 			openWorldHint: true,
 			readOnlyHint: true
 		},
-		description: "List or search MCP providers and active MCP tools. When provider is supplied and not yet active, Junior connects to it on demand and returns tool descriptors including schemas. Without provider, returns active tools plus matching configured providers without connecting. Use when choosing a provider tool or when callMcpTool arguments are unclear.",
+		description: "List or search MCP providers and active MCP tools. When provider is supplied and not yet active, the runtime connects to it on demand and returns tool descriptors including schemas. Without provider, returns active tools plus matching configured providers without connecting. Use when choosing a provider tool or when callMcpTool arguments are unclear.",
 		inputSchema: z.object({
 			query: z.string().min(1).describe("Optional search terms describing the MCP tool or arguments needed.").optional(),
-			provider: z.string().min(1).describe("Optional provider name to list or search within. If configured but not yet connected, Junior activates it on demand.").optional(),
+			provider: z.string().min(1).describe("Optional provider name to list or search within. If configured but not yet connected, the runtime activates it on demand.").optional(),
 			intent: z.string().min(1).describe("Set this when you pass provider. A short purpose to show the user if this call needs them to connect their account, for example \"search Notion for the Q3 offsite doc\".").optional(),
 			max_results: z.number().int().min(1).max(MAX_RESULTS$2).describe("Maximum matching tool descriptors to return.").optional()
 		}).strict(),
@@ -7628,15 +7691,7 @@ const searchedResourceTypeSchema = z.object({
 	identifierFormat: z.string().optional(),
 	supportedEvents: z.array(z.string()),
 	suggestedEvents: z.array(z.string()).optional(),
-	matchFields: z.record(z.string(), z.object({
-		kind: z.enum([
-			"boolean",
-			"string",
-			"number"
-		]),
-		description: z.string(),
-		enum: z.array(z.string()).optional()
-	}).strict()).optional()
+	matchFields: z.record(z.string(), eventMatchFieldSchema).optional()
 }).strict();
 const outputSchema$4 = juniorToolOutputSchema.extend({
 	query: z.string().nullable(),
@@ -7666,7 +7721,7 @@ function createSearchEventTypesTool(catalog) {
 			openWorldHint: false,
 			readOnlyHint: true
 		},
-		description: "Search the event types currently enabled without creating anything. Includes plugin resources and core Workspace snapshot events. Use watchEvents for temporary updates in the current conversation; use createEventAutomation for durable automation. This tool does not watch a resource, create an automation, or list concrete resources.",
+		description: "Search the event types currently enabled without creating anything. Use only when the user asks what events are supported or the required resource type or event name is unclear. Includes plugin resources and core Workspace snapshot events. Use watchEvents for temporary updates in the current conversation; use createEventAutomation for durable automation. This tool does not watch a resource, create an automation, or list concrete resources.",
 		inputSchema: z.object({
 			query: z.string().nullable().describe("Optional terms matching a namespace, resource type, or event name. Resource types that match more terms come first. Empty lists all enabled event types.").optional(),
 			namespace: eventNamespaceSchema(catalog).nullable().describe("Optional enabled plugin namespace to search within.").optional(),
@@ -7801,15 +7856,7 @@ function inputSchema(catalog) {
 		match: registeredEventMatchSchema(),
 		intent: z.string().trim().min(1).max(4e3).describe("Concise reason this conversation wants these events, used when an event arrives."),
 		ttlMs: z.coerce.number().describe("How long to keep the subscription active. Defaults to 14 days and must not exceed 30 days.").optional()
-	}).strict().superRefine((subscription, context) => {
-		subscription.events.forEach((eventType, index) => {
-			if (!pluginSupportsEvent(catalog, subscription.namespace, subscription.resourceType, eventType)) context.addIssue({
-				code: "custom",
-				message: `Resource type "${subscription.namespace}:${subscription.resourceType}" does not support event "${eventType}".`,
-				path: ["events", index]
-			});
-		});
-	});
+	}).strict();
 }
 const stopWatchingActionSchema = z.object({
 	execution_tool: z.literal("executeTool"),
@@ -7854,17 +7901,17 @@ function createWatchEventsTool(context, catalog) {
 		inputSchema: inputSchema(catalog),
 		outputSchema: outputSchema$2,
 		async execute(input) {
-			if (input.namespace === "junior" && input.resourceType === "timer") throw new ToolInputError("Use watchTimer to create a timer Watch.");
-			if (input.namespace === "slack") throw new ToolInputError("Slack channel messages can trigger only an event automation in that channel. Use createEventAutomation.");
+			const unavailable = eventWatchUnavailable(catalog, input.namespace, input.resourceType);
+			if (unavailable) throw new ToolInputError(unavailable);
 			const events = cleanStrings(input.events);
-			for (const eventType of events) if (!pluginSupportsEvent(catalog, input.namespace, input.resourceType, eventType)) throw new ToolInputError(`Resource type "${input.namespace}:${input.resourceType}" does not support event "${eventType}".`);
 			const intent = input.intent.trim();
 			if (!intent) throw new ToolInputError("intent is required");
-			const match = requireSupportedEventMatch(catalog, {
+			const match = requireValidEventTrigger(catalog, {
+				events,
 				match: input.match,
 				namespace: input.namespace,
 				resourceType: input.resourceType
-			});
+			}, "watch");
 			const nowMs = Date.now();
 			const subscription = await createWatch({
 				conversationId: context.conversationId,
@@ -7988,7 +8035,8 @@ const compactEventAutomationResultSchema = z.object({
 		label: z.string().min(1),
 		events: z.array(z.string().min(1)).min(1),
 		match: z.record(z.string(), z.unknown()).optional(),
-		available: z.boolean()
+		available: z.boolean(),
+		problems: z.array(z.string().min(1)).min(1).optional()
 	}).strict(),
 	credentialMode: z.enum(["system", "creator"]),
 	isCreator: z.boolean(),
@@ -8026,15 +8074,9 @@ function registeredEventAutomationTriggerSchema(catalog) {
 		match: registeredEventMatchSchema()
 	}).strict();
 }
-/** Reject an event-automation trigger that is no longer supported by the catalog. */
+/** Reject an event-automation trigger that cannot work with the enabled plugins. */
 function requireSupportedEventAutomationTrigger(catalog, trigger) {
-	const plugins = automationEventCatalog(catalog);
-	for (const eventType of trigger.events) if (!pluginSupportsEvent(plugins, trigger.namespace, trigger.resourceType, eventType)) throw new ToolInputError(`Resource type "${trigger.namespace}:${trigger.resourceType}" does not support event "${eventType}".`);
-	return requireSupportedEventMatch(plugins, {
-		match: trigger.match,
-		namespace: trigger.namespace,
-		resourceType: trigger.resourceType
-	});
+	return requireValidEventTrigger(automationEventCatalog(catalog), trigger, "event_automation");
 }
 /** Require the active Slack authority used for event-automation management. */
 function requireEventAutomationSlackContext(context) {
@@ -8069,12 +8111,18 @@ async function writableEventAutomation(context, id) {
 	if (!task || task.status === "deleted" || !eventAutomationIsWritableFrom(task, destination)) throw new ToolInputError("Event automation was not found.");
 	return task;
 }
-function eventAutomationTriggerAvailable(task, catalog) {
-	const registration = automationEventCatalog(catalog)[task.trigger.namespace];
-	return Boolean(registration && task.trigger.events.every((eventType) => registration.resourceTypes.some((resourceType) => resourceType.supportedEvents.includes(eventType))));
+/**
+* Describe a saved trigger with the enabled plugins. Its problems say why it
+* cannot work: a plugin can remove or rename a resource type, event, or filter
+* after the trigger was saved. Resource types with `automation: false` never
+* dispatch event automations.
+*/
+function describeEventAutomationTrigger(trigger, catalog) {
+	return describeRegisteredEventTrigger(automationEventCatalog(catalog), trigger);
 }
 /** Project an event automation into the bounded tool-result shape. */
 function compactEventAutomation(task, catalog, requesterSlackUserId) {
+	const { problems } = describeEventAutomationTrigger(task.trigger, catalog);
 	return compactEventAutomationResultSchema.parse({
 		id: task.id,
 		status: task.status,
@@ -8089,7 +8137,8 @@ function compactEventAutomation(task, catalog, requesterSlackUserId) {
 			label: task.trigger.label,
 			events: task.trigger.events,
 			...task.trigger.match ? { match: task.trigger.match } : void 0,
-			available: eventAutomationTriggerAvailable(task, catalog)
+			available: problems.length === 0,
+			...problems.length > 0 ? { problems } : void 0
 		},
 		credentialMode: task.credentialMode,
 		isCreator: task.createdBy.slackUserId === requesterSlackUserId,
@@ -8109,7 +8158,7 @@ function compactEventAutomation(task, catalog, requesterSlackUserId) {
 /** Return the standard successful event-automation tool result. */
 async function eventAutomationToolResult(conversationId, task, catalog, requesterSlackUserId) {
 	const automation = compactEventAutomation(task, catalog, requesterSlackUserId);
-	const filters = Object.entries(task.trigger.match ?? {}).map(([key, value]) => `${key} = ${JSON.stringify(value)}`);
+	const description = describeEventAutomationTrigger(task.trigger, catalog);
 	const title = automation.title ?? fallbackShortTitle(task.task.text, "Event automation");
 	return {
 		automation,
@@ -8121,13 +8170,9 @@ async function eventAutomationToolResult(conversationId, task, catalog, requeste
 			title,
 			url: automation.dashboardUrl,
 			description: task.task.text,
-			status: automation.trigger.available ? "ready" : "unavailable",
-			trigger: [
-				task.trigger.label,
-				task.trigger.events.join(", "),
-				...filters
-			].join(" · "),
-			warning: !automation.trigger.available ? "Trigger unavailable. This automation cannot receive events." : void 0
+			status: description.problems.length === 0 ? "ready" : "unavailable",
+			trigger: eventTriggerText(task.trigger.label, description),
+			warning: description.problems.length > 0 ? ["Trigger unavailable.", ...description.problems].join(" ") : void 0
 		}])
 	};
 }
@@ -8155,7 +8200,7 @@ function createEventAutomationTool(context, catalog) {
 			readOnlyHint: false
 		},
 		executionMode: "sequential",
-		description: "Create a durable event automation in the active Slack channel or DM, never a thread. It executes the supplied instruction for every matching event. Use for whenever-this-happens-do-X automation; ordinary watch, notify, or tell-me-when requests use watchEvents instead. The automation may use the creator's connected credentials. Prefer a subscribable tool result when available.",
+		description: "Create a durable event automation in the active Slack channel or DM, never a thread. It executes the supplied instruction for every matching event. Use only when the user explicitly asks for an event automation or durable whenever-this-happens-do-X automation; ordinary watch, notify, or tell-me-when requests use watchEvents instead. When the resource and events are known, create it without redundant confirmation. The automation may use the creator's connected credentials. Prefer a subscribable tool result when available.",
 		inputSchema: z.object({
 			instruction: automationInstructionToolSchema,
 			title: z.string().trim().min(1).max(60).nullable().describe("Optional short display title. Omit or use null to generate one from the task instruction.").optional(),
@@ -8269,7 +8314,7 @@ function createListEventAutomationsTool(context, catalog) {
 			openWorldHint: false,
 			readOnlyHint: true
 		},
-		description: "List event automations for the current destination. Each result says whether the requester is the creator and whether its trigger is available.",
+		description: "List event automations for the current destination, not one thread. Each result says whether the requester is the creator (isCreator); only the creator can change its credential use. Warn when trigger.available is false and explain trigger.problems: the automation stays stored, but a plugin no longer supports its resource type, an event, or a filter. Update the trigger to fix it. Public automations can also be updated or deleted by id from another destination in the same workspace.",
 		inputSchema: z.object({}).strict(),
 		outputSchema: eventAutomationListToolResultSchema,
 		async execute() {
@@ -8724,7 +8769,7 @@ function createSlackScheduleCreateAutomationTool(context) {
 			openWorldHint: true,
 			readOnlyHint: false
 		},
-		description: "Create a one-time or recurring Junior task in the active Slack channel. Store the requested future work; do not perform it or check its service access now unless the user also asks for that.",
+		description: "Create a one-time or recurring scheduled task in the active Slack channel. Store the requested future work; do not perform it or check its service access now unless the user also asks for that.",
 		executionMode: "sequential",
 		inputSchema: z.object({
 			instruction: automationInstructionToolSchema,
@@ -8822,7 +8867,7 @@ function createSlackScheduleDeleteAutomationTool(context) {
 			openWorldHint: false,
 			readOnlyHint: false
 		},
-		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.",
+		description: "Delete one scheduled 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.extend({ removedCards: z.array(removedCardSchema) }),
@@ -8953,7 +8998,7 @@ function createSlackScheduleRunAutomationNowTool(context) {
 			openWorldHint: true,
 			readOnlyHint: false
 		},
-		description: "Queue an existing active scheduled Junior task to run as soon as possible, without changing its cadence. Use when the user asks to run an existing scheduled automation now. Use only task IDs returned for this conversation.",
+		description: "Queue an existing active scheduled task to run as soon as possible, without changing its cadence. Use when the user asks to run an existing scheduled automation now. Use only task IDs returned for this conversation.",
 		executionMode: "sequential",
 		inputSchema: z.object({ automationId: z.string().min(1).describe("ID of the active task to run now. Must be from this active Slack conversation.") }),
 		outputSchema: scheduleAutomationToolResultSchema,
@@ -9279,7 +9324,7 @@ async function joinPublicChannelForRead(args) {
 	}
 }
 /** Model-facing Slack channel id or known channel name parameter. */
-const slackChannelRefParam = z.string().trim().min(1).max(160).describe("Slack channel id (`C123`), mention (`<#C123>` / `<#C123|name>`), Junior slack reference (`slack:C123`), or a channel name Junior already knows in this workspace.");
+const slackChannelRefParam = z.string().trim().min(1).max(160).describe("Slack channel id (`C123`), mention (`<#C123>` / `<#C123|name>`), Slack reference (`slack:C123`), or a channel name you already know in this workspace.");
 /**
 * Resolve a channel reference from a tool param value.
 *
@@ -9288,7 +9333,7 @@ const slackChannelRefParam = z.string().trim().min(1).max(160).describe("Slack c
 */
 async function resolveSlackChannelRef(input) {
 	const trimmed = input.value.trim();
-	if (!trimmed) throw new ToolInputError(`Invalid \`${input.field}\`. Use a channel id (\`C123\`), a Slack mention (\`<#C123>\`), a Junior slack reference (\`slack:C123\`), or a channel name Junior already knows.`);
+	if (!trimmed) throw new ToolInputError(`Invalid \`${input.field}\`. Use a channel id (\`C123\`), a Slack mention (\`<#C123>\`), a Slack reference (\`slack:C123\`), or a channel name you already know.`);
 	const channelId = parseSlackChannelReferenceId(trimmed);
 	if (channelId) return { channelId };
 	const known = await getConversationStore().findSlackDestinationByName({
@@ -9300,7 +9345,7 @@ async function resolveSlackChannelRef(input) {
 		channelId: knownChannelId,
 		...known.channelName ? { channelName: known.channelName } : void 0
 	};
-	throw new ToolInputError(`Unknown \`${input.field}\` \`${trimmed}\`. Use a channel id (\`C123\`), a Slack mention (\`<#C123>\`), a link, or a channel name Junior has already seen in this workspace. Public search can discover channels; plain names are not scanned from Slack.`);
+	throw new ToolInputError(`Unknown \`${input.field}\` \`${trimmed}\`. Use a channel id (\`C123\`), a Slack mention (\`<#C123>\`), a link, or a channel name you already saw in this workspace. Public search can discover channels; plain names are not scanned from Slack.`);
 }
 /**
 * Resolve an optional channel reference, falling back to the active channel.
@@ -9607,7 +9652,7 @@ function createSlackConversationBriefSearchPort(teamId) {
 /** Deferred tool catalog source for retained Junior conversations. */
 const CONVERSATIONS_TOOL_SOURCE = {
 	id: "conversations",
-	description: "Search messages and events in retained Junior conversations."
+	description: "Search messages and events in retained conversations."
 };
 // src/chat/slack/tools/conversation-message-search.ts
 const DEFAULT_LIMIT$3 = 20;
@@ -13351,19 +13396,33 @@ function createWebSearchTool(modelId, override) {
 			const controller = new AbortController();
 			const credential = await resolveGatewayCredential();
 			const provider = createGatewayProvider(credential ? { apiKey: credential.token } : {});
-			const results = parseSearchResults((await withTimeout(generateText({
-				model: provider.chat(modelId),
-				prompt: query,
-				tools: { [SEARCH_TOOL_NAME]: provider.tools.parallelSearch({
-					mode: "agentic",
-					maxResults
-				}) },
-				toolChoice: {
-					type: "tool",
-					toolName: SEARCH_TOOL_NAME
-				},
-				abortSignal: controller.signal
-			}), SEARCH_TIMEOUT_MS, "webSearch", { onTimeout: () => controller.abort() })).toolResults, maxResults);
+			const results = parseSearchResults((await withSpan(`chat ${modelId}`, "gen_ai.chat", {}, async (setSpanAttributes) => {
+				const response = await withTimeout(generateText({
+					model: provider.chat(modelId),
+					prompt: query,
+					tools: { [SEARCH_TOOL_NAME]: provider.tools.parallelSearch({
+						mode: "agentic",
+						maxResults
+					}) },
+					toolChoice: {
+						type: "tool",
+						toolName: SEARCH_TOOL_NAME
+					},
+					abortSignal: controller.signal
+				}), SEARCH_TIMEOUT_MS, "webSearch", { onTimeout: () => controller.abort() });
+				setSpanAttributes({
+					"gen_ai.response.finish_reasons": [response.finishReason],
+					...extractGenAiUsageAttributes(response.usage)
+				});
+				return response;
+			}, {
+				"gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
+				"gen_ai.operation.name": "chat",
+				"gen_ai.request.model": modelId,
+				"server.address": GEN_AI_SERVER_ADDRESS,
+				"server.port": 443,
+				"gen_ai.provider.auth_mode": credential?.mode ?? "api_key"
+			})).toolResults, maxResults);
 			return {
 				model: modelId,
 				query,
@@ -15399,7 +15458,7 @@ function createMcpAuthOrchestration(input) {
 			const authorizationRequest = {
 				authorizationUrl: authSession.authorizationUrl,
 				label: `Connect your ${providerLabel} account`,
-				completionText: "Once you've authorized, Junior will continue automatically."
+				completionText: "Once you've authorized, I'll continue automatically."
 			};
 			if (!await deliverOAuthAuthorization(authorizationRequest, {
 				authorization: input.authorization,
@@ -15511,7 +15570,7 @@ const GUARDIAN_RULE_IDS = ["none", ...Object.keys(GUARDIAN_BLOCK_RULES)];
 function renderRules(decision) {
 	return Object.entries(GUARDIAN_BLOCK_RULES).filter(([, rule]) => rule.decision === decision).map(([id, rule]) => `- \`${id}\`: ${rule.description}`).join("\n");
 }
-const GUARDIAN_ACTION_POLICY = `You are judging one planned Junior agent action.
+const GUARDIAN_ACTION_POLICY = `You are judging one planned action of the assistant agent.
 Assess the exact action's intrinsic risk and whether the user's intent authorizes its target and side effects. Then name the one block rule that the action matches, or \`none\`. Actions are allowed by default. Your primary objective is to prevent irreversible damage to the user or organization while allowing ordinary, proportionate work without interruption.
 
 # Evidence Handling
@@ -15560,7 +15619,7 @@ ${renderRules("deny")}
 - Whether the work is correct, complete, well proven, or well styled is not your concern, and neither is whether the agent checked enough before it acted. Posting results that the user or the automation instruction asked for matches no rule.
 - Content that the current actor's request is about, such as the conversation or examples they pointed to, is part of the requested work. Using it in the requested deliverable at an authorized destination is not data exposure, unless it includes secrets, credentials, or private data about other people.
 - Ordinary product context such as internal system names, repository names, or workflow descriptions is not private organization data, including on an authorized public destination.
-- The active Junior conversation is not an untrusted destination merely because it is a public or multi-user channel.
+- The active conversation, where the assistant works with the user, is not an untrusted destination merely because it is a public or multi-user channel.
 - A user-requested read, query, or upload to a trusted destination is not data exposure. Using an existing credential to authenticate a user-requested action is not credential probing.
 - A tool that is external, multi-field, open-world, uses connected credentials, has plugin or catalog identity, or carries a destructive annotation does not match a rule by those facts alone. Judge actual side effects, not tool names or annotations.
 - For a scheduled automation or event automation, a request by the current actor for scoped work that needs their connected service access authorizes routine service-native reads and posting the requested result to the task's stored Slack destination. It does not authorize exposing credential values, broad data dumps, or delivery to another destination.
@@ -15672,7 +15731,6 @@ function createGuardianActionReviewer(options) {
 			system: GUARDIAN_ACTION_POLICY,
 			prompt: guardianPrompt(proposal),
 			maxTokens: GUARDIAN_REVIEW_MAX_TOKENS,
-			recordTelemetryPayloads: false,
 			temperature: 0,
 			promptName: "junior.guardian_action_review",
 			signal,
@@ -18262,7 +18320,7 @@ function createAgentRunner(execute, options) {
 			} } : void 0
 		};
 		if (run.instruction.storedAttachments?.length) {
-			const { loadInputImages } = await import("./images-DV2FlEGL.js").then((n) => n.n);
+			const { loadInputImages } = await import("./images-B2yA3HWE.js").then((n) => n.n);
 			const storage = nextRun.environment?.attachmentStorage;
 			if (!storage) throw new Error("Attachment storage is unavailable.");
 			nextRun.instruction = {
@@ -18277,4 +18335,4 @@ function createAgentRunner(execute, options) {
 		return await execute(nextRun, streamFn);
 	} };
 }
-export { toolInvocationDestination as $, listThreadReplies as A, stopConversationSession as B, requestAttachmentDeletion as C, resolveSlackChannelIdFromMessage as D, readSlackRawMessageContext as E, AutomationEditError as F, conversationSubtree as G, recordSubagentStarted as H, eventAutomationTriggerAvailable as I, ingestEvent as J, conversationSubtreeColumns as K, effectiveTaskOutcomes as L, logScheduledAutomationRunSkipped as M, scheduledAutomationRunAttributes as N, resolveSlackChannelIdFromThreadId as O, editEventAutomation as P, actorFromRun as Q, resolveTaskOutcomes as R, readLiveAttachment as S, parseSlackThreadId as T, listChildAgents as U, recordSubagentEnded as V, listUnreportedSiblingAgents as W, withoutSavedSteeringMessages as X, buildSteeringPiMessage as Y, RetryableDeliveryError as Z, unpublishedArtifactHeaders as _, finalizeMcpAuthorization as a, renderBlockText as b, deleteMcpServerSessionId as c, getMcpStoredOAuthCredentials as d, readBlockedReport as et, putMcpStoredOAuthCredentials as f, readPublicArtifact as g, publicArtifactHeaders as h, buildAuthPauseResponse as i, editScheduledAutomation as j, getConversationInfo as k, deleteMcpStoredOAuthCredentials as l, readStats as m, executeAgentRun as n, deleteMcpAuthSession as o, latestProgressStatus as p, processWorkspaceSnapshotJob as q, createContextCompactor as r, deleteMcpAuthSessionsForUserProvider as s, createAgentRunner as t, shouldEmitDevAgentTrace as tt, getMcpAuthSession as u, lookupSlackUserProfile as v, storeAttachment as w, collectAttachmentGarbage as x, renderAttachmentText as y, stopChildAgentsOf as z };
+export { actorFromRun as $, listThreadReplies as A, stopChildAgentsOf as B, requestAttachmentDeletion as C, resolveSlackChannelIdFromMessage as D, readSlackRawMessageContext as E, AutomationEditError as F, listUnreportedSiblingAgents as G, recordSubagentEnded as H, describeEventAutomationTrigger as I, processWorkspaceSnapshotJob as J, conversationSubtree as K, effectiveTaskOutcomes as L, logScheduledAutomationRunSkipped as M, scheduledAutomationRunAttributes as N, resolveSlackChannelIdFromThreadId as O, editEventAutomation as P, RetryableDeliveryError as Q, resolveTaskOutcomes as R, readLiveAttachment as S, parseSlackThreadId as T, recordSubagentStarted as U, stopConversationSession as V, listChildAgents as W, buildSteeringPiMessage as X, ingestEvent as Y, withoutSavedSteeringMessages as Z, unpublishedArtifactHeaders as _, finalizeMcpAuthorization as a, renderBlockText as b, deleteMcpServerSessionId as c, getMcpStoredOAuthCredentials as d, toolInvocationDestination as et, putMcpStoredOAuthCredentials as f, readPublicArtifact as g, publicArtifactHeaders as h, buildAuthPauseResponse as i, editScheduledAutomation as j, getConversationInfo as k, deleteMcpStoredOAuthCredentials as l, readStats as m, executeAgentRun as n, shouldEmitDevAgentTrace as nt, deleteMcpAuthSession as o, latestProgressStatus as p, conversationSubtreeColumns as q, createContextCompactor as r, deleteMcpAuthSessionsForUserProvider as s, createAgentRunner as t, readBlockedReport as tt, getMcpAuthSession as u, lookupSlackUserProfile as v, storeAttachment as w, collectAttachmentGarbage as x, renderAttachmentText as y, listOwnedWatches as z };