@sentry/junior 0.205.0 → 0.207.0

package/dist/{agent-D4nu8MQV.js → agent-CmQlX68D.js}

@@ -1,25 +1,28 @@
-import { A as createProviderError, C as MODEL_HANDOFF_SUMMARY_PREFIX, D as unwrapCurrentInstruction, E as renderCurrentInstruction, F as MISSING_GATEWAY_CREDENTIALS_ERROR, I as getGatewayApiKey, L as resolveGatewayCredential, M as getProviderErrorAttributes, O as escapeXml, P as isProviderRetryError, S as COMPACTION_SUMMARY_PREFIX, T as isCompactionSummaryText, _ as completeObject, b as resolveGatewayModel, g as GEN_AI_SERVER_ADDRESS, h as GEN_AI_PROVIDER_NAME, j as findProviderError, k as ProviderError, m as normalizeSlackEmojiName, n as botConfig, v as completeText, w as hasCompactedConversationContext, x as ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX } from "./config-BOtJQ7Pc.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-BMJzdDlP.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-Bp297GA0.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-Dx0S5k2z.js";
 import { _ as withActiveSpan, m as startInactiveSpan } from "./sentry-CD3SdJl-.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-BZRA6Pes.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-BUfel19D.js";
+import { h as normalizeSlackEmojiName, n as botConfig } from "./config-G2gv97R1.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-B45_WqVX.js";
-import { $ as RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS, B as getSlackClient, Bt as parseDestination, C as setWorkspaceSnapshotBuild, Ct as getConversationEventStore, D as tryWorkspaceRepoCheckoutPath, Dt as getSqlExecutor, E as getWorkspaceSnapshotBuilder, Et as getDb, G as withSlackRetries, I as SlackActionError, L as downloadPrivateSlackFile, O as workspaceRepoCheckoutPath, Q as getSlackToolContext, R as getFilePermalink, S as setWorkspaceSnapshot, T as deleteWorkspaceSnapshotBuilders, Tt as getConversationStore, U as normalizeSlackConversationId, V as isConversationScopedChannel, Y as readActorIdentity, _ as listWorkspaces, _t as createPluginLogger, b as invalidateReadySnapshot, c as getPluginTools, ct as findMatchingResourceEventSubscriptions, ft as getDashboardTaskLink, g as getWorkspaceByName, h as getWorkspace, it as cancelSubscriptions, k as resolveChannelCapabilities, l as getPluginUserPromptContributions, lt as listResourceEventSubscriptions, m as deleteWorkspace, nt as STOP_WATCHING_TOOL_NAME, ot as createResourceEventSubscription, p as createWorkspace, r as createPluginHookRunner, rt as cancelResourceEventSubscription, s as getPluginSystemPromptContributions, st as deliverResourceEventSubscription, tt as RESOURCE_WATCH_TOOL_SOURCE, u as getPlugins, ut as JUNIOR_THREAD_STATE_TTL_MS, v as updateWorkspace, w as SANDBOX_RUNTIME, wt as getConversationMessageSearchStore, x as loadSnapshotsForProfile, y as WorkspaceValidationError } from "./agent-hooks-DXHpTJ4m.js";
-import { E as juniorArtifacts, a as juniorSchedulerRuns, d as AGENT_INVOCATION_MAILBOX_STATUSES, w as juniorIdentities, x as juniorAttachments } from "./executor-BlUhFL7_.js";
-import { d as instructionProvenanceFor, f as sameActorIdentity, l as contextProvenance, t as KNOWN_CONVERSATION_EVENT_TYPES, u as instructionActors } from "./history-CqTuSAdI.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, Ft as getConversationStore, It as getDb, J as withSlackRetries, K as normalizeSlackConversationId, Lt as getSqlExecutor, M as resolveChannelCapabilities, Nt as getConversationEventStore, O as deleteWorkspaceSnapshotBuilders, Pt as getConversationMessageSearchStore, Q as readActorIdentity, S as WorkspaceValidationError, T as setWorkspaceSnapshot, U as getSlackClient, V as getFilePermalink, W as isConversationScopedChannel, Xt as parseDestination, _ as deleteWorkspace, at as STOP_WATCHING_TOOL_NAME, b as listWorkspaces, bt as createPluginLogger, c as getPluginTools, dt as findMatchingWatches, 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, 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, ut as deliverWatch, v as getWorkspace, w as loadSnapshotsForProfile, x as updateWorkspace, y as getWorkspaceByName, z as SlackActionError } from "./agent-hooks-BBX9p6aG.js";
+import { n as juniorDestinations } from "./destinations-BeBiJeEM.js";
+import { D as juniorArtifacts, S as juniorAttachments, T as juniorIdentities, a as juniorSchedulerRuns, d as AGENT_INVOCATION_MAILBOX_STATUSES, g as juniorConversationBriefs, w as juniorConversations, y as juniorConversationAnnotations } from "./executor-BZu1Ta06.js";
+import { A as briefLinkSchema, F as KNOWN_CONVERSATION_EVENT_TYPES, G as instructionProvenanceFor, K as sameActorIdentity, M as conversationBriefSchema, U as contextProvenance, W as instructionActors, j as briefOutcomeStatusSchema } from "./conversation-AA4R1VUn.js";
 import { a as listReferenceFiles, c as soulPathCandidates, l as worldPathCandidates } from "./package-discovery-7a9YqLhE.js";
-import { a as resolvePluginCommandEnv, c as getOAuthProviderErrorAttributes, i as resolveAuthTokenPlaceholder, o as OAuthProviderError, s as fetchWithBoundedOAuthErrorBodies, u as CredentialUnavailableError } from "./registry-BA0__8ai.js";
-import { n as pluginCatalogRuntime } from "./catalog-runtime-CXw3asJD.js";
-import { a as parseSkillInvocation, n as findSkillByName, r as loadSkillsByName, t as discoverSkills } from "./skills-DJOlYdBs.js";
-import { A as normalizeToLf$1, At as retainRuntimeTurnContext, B as openConversationProjection, C as DEFAULT_SEARCH_COMMAND_TIMEOUT_MS, Ct as hasRuntimeTurnContext, D as getRipgrepSearchLocation, Dt as isToolResultError, E as collectFiles, Et as isContinuablePiBoundary, G as recordAuthorizationRequested, H as recordAttachmentsDelivered, I as loadConnectedMcpProviders, K as recordGuardianActionReviewed, L as loadConversationProjection, M as resolveWorkspacePath, Mt as trimTrailingAssistantMessages, N as truncateText$1, Nt as TURN_CONTEXT_TAG, O as isMissingPathError, Ot as isToolResultMessage, S as resolveRepositoryInstructionsForDirectories, St as getUserMessageInstructionText, T as RIPGREP_EXCLUDED_GLOBS, Tt as isAssistantMessage, V as recordAgentsInstructionsUpdated, X as recordTurnRoute, Y as recordToolExecutionStarted, _ as AGENTS_REPLACEMENT_NOTICE, _t as historyItemFromPiMessage, b as listRepositoryDirectories, bt as getPiMessageRole, f as TurnSliceLimitExceededError, g as AGENTS_REMOVAL_NOTICE, gt as getAgentContextInputLimitTokens, h as isTurnExecutionLimitExceededError, ht as getAgentContextCompactionTriggerTokens, j as positiveInteger$1, jt as stripRuntimeTurnContext, k as missingPathSearchResult, kt as normalizeToolNameFromResult, mt as estimateTextTokens, n as loadTurnCheckpoint, p as assertTurnToolCallLimit, q as recordMcpProviderConnected, r as saveTurnCheckpoint, t as continuableMessages, v as buildAgentsInstructionsMessage, vt as piMessageFromHistoryItem, w as MAX_TEXT_CHARS, x as renderAgentsInstructions, xt as getTerminalAssistantMessages, y as findVisibleAgentsInstructions, yt as extractAssistantText, z as loadTurnRoute } from "./checkpoint-CrViJ8Ps.js";
-import { a as hasAgentTurnUsage, c as generateShortTitle, l as resolveTaskTitle, o as ToolInputError, t as addAgentTurnUsage } from "./usage-B5SfMb3H.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-T0tXE4zu.js";
-import { $ as workspaceSnapshotFinishedEvent, B as createEventTask, C as SCHEDULED_TASK_SYSTEM_ACTOR, D as eventTaskMatchesDestination, E as eventTaskListToolResultSchema, F as effectiveTaskOutcomes, Ht as injectContinuationToolName, I as moveTaskOutcomes, L as resolveTaskOutcomes, M as requireEventTaskSlackContext, N as requireSupportedEventTaskTrigger, O as eventTaskSuccess, P as writableEventTask, Q as WORKSPACE_SNAPSHOT_READY_EVENT, R as taskOutcomeInputSchema, T as compactEventTask, Ut as juniorToolOutputSchema, V as deleteEventTask, W as getEventTask, Wt as makeStructuredToolOutput, X as getResourceEventCatalog, Y as saveEventTask, Z as WORKSPACE_SNAPSHOT_FAILED_EVENT, at as pluginSupportsEvent, c as parseSlackThreadId, ct as registeredResourceTypeSchema, et as workspaceSnapshotWatch, f as createScheduledTask, g as listScheduledTasksForTeam, i as readLiveAttachment, it as normalizeEventIdentifier, j as registeredEventTaskTriggerSchema, k as eventTaskToolResultSchema, lt as requireSupportedResourceEventMatch, nt as hasPluginResourceEventCatalogEntries, ot as registeredEventTypeSchema, pt as appendAndEnqueueInboundMessage, q as listEventTasksForTeam, rt as hasResourceEventCatalogEntries, s as storeAttachments, st as registeredResourceEventMatchSchema, t as incrementStat, tt as eventNamespaceSchema, ut as resourceEventGuidance, v as readScheduledTask, y as saveScheduledTask } from "./stats-3YZn-Swi.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-CUbXq06G.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-C04colea.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-bvD1ORdv.js";
+import { a as resolvePluginCommandEnv, c as getOAuthProviderErrorAttributes, i as resolveAuthTokenPlaceholder, o as OAuthProviderError, s as fetchWithBoundedOAuthErrorBodies, u as CredentialUnavailableError } from "./registry-CWKdLCTG.js";
+import { n as pluginCatalogRuntime } from "./catalog-runtime-1BZEOR8J.js";
+import { a as parseSkillInvocation, n as findSkillByName, r as loadSkillsByName, t as discoverSkills } from "./skills-D9WesdJJ.js";
+import { A as normalizeToLf$1, At as retainRuntimeTurnContext, B as openConversationProjection, C as DEFAULT_SEARCH_COMMAND_TIMEOUT_MS, Ct as hasRuntimeTurnContext, D as getRipgrepSearchLocation, Dt as isToolResultError, E as collectFiles, Et as isContinuablePiBoundary, G as recordAuthorizationRequested, H as recordAttachmentsDelivered, I as loadConnectedMcpProviders, K as recordGuardianActionReviewed, L as loadConversationProjection, M as resolveWorkspacePath, Mt as trimTrailingAssistantMessages, N as truncateText$1, Nt as TURN_CONTEXT_TAG, O as isMissingPathError, Ot as isToolResultMessage, S as resolveRepositoryInstructionsForDirectories, St as getUserMessageInstructionText, T as RIPGREP_EXCLUDED_GLOBS, Tt as isAssistantMessage, V as recordAgentsInstructionsUpdated, X as recordTurnRoute, Y as recordToolExecutionStarted, _ as AGENTS_REPLACEMENT_NOTICE, _t as historyItemFromPiMessage, b as listRepositoryDirectories, bt as getPiMessageRole, f as TurnSliceLimitExceededError, g as AGENTS_REMOVAL_NOTICE, gt as getAgentContextInputLimitTokens, h as isTurnExecutionLimitExceededError, ht as getAgentContextCompactionTriggerTokens, j as positiveInteger$1, jt as stripRuntimeTurnContext, k as missingPathSearchResult, kt as normalizeToolNameFromResult, mt as estimateTextTokens, n as loadTurnCheckpoint, p as assertTurnToolCallLimit, q as recordMcpProviderConnected, r as saveTurnCheckpoint, t as continuableMessages, v as buildAgentsInstructionsMessage, vt as piMessageFromHistoryItem, w as MAX_TEXT_CHARS, x as renderAgentsInstructions, xt as getTerminalAssistantMessages, y as findVisibleAgentsInstructions, yt as extractAssistantText, z as loadTurnRoute } from "./checkpoint-B-JO5F3c.js";
+import { a as hasAgentTurnUsage, c as generateShortTitle, l as resolveTaskTitle, o as ToolInputError, t as addAgentTurnUsage } from "./usage-WRXkNOHp.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-d-fKypxo.js";
+import { $ as workspaceSnapshotFinishedEvent, B as createEventAutomation, C as SCHEDULED_AUTOMATION_SYSTEM_ACTOR, D as eventAutomationMatchesDestination, E as eventAutomationListToolResultSchema, F as effectiveTaskOutcomes, Ht as injectContinuationToolName, I as moveTaskOutcomes, 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 juniorToolOutputSchema, V as deleteEventAutomation, W as getEventAutomation, Wt as makeStructuredToolOutput, 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-CFlUGqVA.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-DIZ4iZjS.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-CQD4HKK2.js";
+import { r as EVENT_AUTHOR_ID } from "./prompt-x-0ZtTyb.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-BhRB1s2A.js";
 import { t as getVercelConversationWorkQueue } from "./vercel-queue-DIkVcfK4.js";
-import { a as getTurnRequestDeadline, n as sendNextWorkspaceSnapshotJob, r as sendWorkspaceSnapshotJob } from "./job-queue-DLMqIK74.js";
+import { a as getTurnRequestDeadline, n as sendNextWorkspaceSnapshotJob, r as sendWorkspaceSnapshotJob } from "./job-queue-rnAPfUhP.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";
@@ -29,8 +32,8 @@ import { isDeepStrictEqual } from "node:util";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { z } from "zod";
 import { createHash, createHmac, randomUUID, timingSafeEqual } from "node:crypto";
-import { and, eq, inArray, isNull, or, sql } from "drizzle-orm";
-import { EgressAuthRequired, EgressPolicyDenied, PluginToolInputError, actorSchema, destinationSchema, missingToolAnnotationKeys, pluginAuthorizationSchema, pluginCredentialHeaderTransformSchema, pluginCredentialResultSchema, pluginGrantSchema, pluginProviderAccountSchema, pluginStoredTokensSchema, resourceEventSchema, resourceEventSubscriptionResultSchema, sourceSchema, stableResourceEventMatchKey, taskOutcomeSchema } from "@sentry/junior-plugin-api";
+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 { alias } from "drizzle-orm/pg-core";
 import { Agent, estimateContextTokens } from "@earendil-works/pi-agent-core";
 import fs from "node:fs/promises";
@@ -402,21 +405,22 @@ function buildTurnResult(input) {
 		"app.ai.generated_files": input.generatedFileCount
 	});
 	const usedPrimaryText = Boolean(rawPrimaryText);
+	const suppressedPrimaryText = Boolean(rawPrimaryText && !noReplyRequested && !primaryText);
 	let outcome;
 	if (isProviderError) outcome = "provider_error";
+	else if (suppressedPrimaryText) outcome = "execution_failure";
 	else if (primaryText || completedWithoutTerminalText) outcome = "success";
 	else outcome = "execution_failure";
-	const resolvedOutcome = Boolean(rawPrimaryText && !noReplyRequested && !primaryText) ? "execution_failure" : outcome;
 	if (shouldTrace) logInfo("agent.message.generated", {
 		"app.message.kind": "assistant_outbound",
 		"app.message.length": primaryText.length,
 		"app.message.output": summarizeMessageText(primaryText),
-		"app.ai.outcome": resolvedOutcome,
+		"app.ai.outcome": outcome,
 		"app.ai.assistant_messages": assistantMessages.length,
 		...stopReason ? { "gen_ai.response.finish_reasons": [stopReason] } : void 0
 	});
 	const resolvedDiagnostics = {
-		outcome: resolvedOutcome,
+		outcome,
 		modelId,
 		assistantMessageCount: assistantMessages.length,
 		reasoningLevel: executionProfile.reasoningLevel,
@@ -428,7 +432,7 @@ function buildTurnResult(input) {
 		usage,
 		stopReason,
 		errorMessage,
-		providerError: resolvedOutcome === "provider_error" && errorMessage ? createProviderError(errorMessage, {
+		providerError: outcome === "provider_error" && errorMessage ? createProviderError(errorMessage, {
 			modelId,
 			retryable: lastAssistant !== void 0 && isAssistantMessage(lastAssistant) && isRetryableAssistantError(lastAssistant)
 		}) : void 0
@@ -1143,12 +1147,12 @@ const TOOL_POLICY_RULES = [
 	"- 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 searchResourceEventTypes is exposed, use it only when the user asks what resource events are supported or the required resource type or event name is unclear. It discovers options but does not watch a resource or create a task. When explaining how results can be used, distinguish temporary current-thread watches from durable event tasks.",
-	"- When a tool result includes a subscription, those events are already watched; do not call watchResourceEvents for them. When a tool result includes a subscribable resource with suggestedEvents, use watchResourceEvents 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.",
-	"- Use createEventTask only when the user explicitly asks for an event task or durable whenever-this-happens-do-X automation. Ordinary watch, notify, and tell-me-when requests use watchResourceEvents. When an event task's resource and events are known, create it without redundant confirmation.",
-	"- Event tasks make the task 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 task'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 tasks list for the current destination, not one thread. Public tasks can also be updated or deleted by task id from another destination in the same workspace. When listing them, use createdBy to explain creator-only credential changes and warn when triggerAvailable is false; an unavailable task remains stored but cannot receive events until its plugin event is enabled again.",
-	"- Scheduled tasks make the task 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 credential_mode for the creator default and set system only when the creator explicitly requires it. For later changes, creator always means the task's original created_by 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.",
+	"- 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.",
+	"- 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.",
+	"- Scheduled 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.",
 	"- When another model profile fits the task better, call `handoff` before substantial work. Follow the profile list and selection rules in the tool description.",
 	"- 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.",
 	"- 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."
@@ -1264,14 +1268,14 @@ function formatSourceLines(source) {
 			...source.messageTs ? [`- source.message_ts: ${escapeXml(source.messageTs)}`] : [],
 			...source.threadTs ? [`- source.thread_ts: ${escapeXml(source.threadTs)}`] : []
 		];
-		case "resource_event": return [
-			"- source.kind: resource_event",
+		case "event": return [
+			"- source.kind: event",
 			`- source.namespace: ${escapeXml(source.namespace)}`,
 			`- source.identifier: ${escapeXml(source.identifier)}`,
 			`- source.event_type: ${escapeXml(source.eventType)}`
 		];
-		case "scheduled_task":
-		case "event_task":
+		case "scheduled_automation":
+		case "event_automation":
 		case "plugin_dispatch":
 		case "agent_invocation": return [`- source.kind: ${source.kind}`];
 	}
@@ -2487,8 +2491,9 @@ async function prepareWorkspaceRepositories(params) {
 	const { sandbox, workspace, signal } = params;
 	signal?.throwIfAborted();
 	await params.applyNetworkPolicy(sandbox);
-	await params.prepareRepositories?.(sandbox, workspace, signal);
+	const finalize = await params.prepareRepositories?.(sandbox, workspace, signal);
 	if (params.removeCredentialRoute) await sandbox.update({ networkPolicy: "allow-all" });
+	await finalize?.();
 }
 /** Return bounded setup output for a Workspace failure. */
 function workspaceSetupFailureDetail(input) {
@@ -2611,7 +2616,7 @@ function emptyState(nowMs) {
 /** True when this Source starts an automated Turn rather than a user Turn. */
 function isAutomatedTurnSource(source) {
 	if (!source) return false;
-	return source.kind === "resource_event" || source.kind === "event_task" || source.kind === "scheduled_task" || source.kind === "plugin_dispatch" || source.kind === "agent_invocation";
+	return source.kind === "event" || source.kind === "event_automation" || source.kind === "scheduled_automation" || source.kind === "plugin_dispatch" || source.kind === "agent_invocation";
 }
 /** Plain notice when automatic updates stop until the user replies. */
 function buildAutomatedTurnLimitResponse(args) {
@@ -2823,48 +2828,15 @@ function renderTaskInput(args) {
 	return lines.join("\n");
 }
 //#endregion
-//#region src/chat/resource-events/actor.ts
-/**
-* System author ID stamped on resource-event mailbox messages.
-*
-* Keep this stable so conversation history can recognize the same system input
-* for resource-event Turns.
-*
-* TODO(dcramer): Delete this ID after resumes read resource-event Source.kind
-* from the Turn checkpoint instead of Message author data.
-*/
-const RESOURCE_EVENT_AUTHOR_ID = "UJRNEVENT";
-/** System Message author for resource-event input. */
-const RESOURCE_EVENT_MESSAGE_AUTHOR = {
-	fullName: "Junior event",
-	isBot: true,
-	userId: RESOURCE_EVENT_AUTHOR_ID,
-	userName: "junior-event"
-};
-/** System execution actor for every resource-event turn. */
-const RESOURCE_EVENT_SYSTEM_ACTOR = {
-	platform: "system",
-	name: "resource-event"
-};
-/**
-* Whether a saved Message started a resource-event Turn.
-*
-* TODO(dcramer): Delete this marker check after deployed Turn cursors all store
-* Source and Actor. `eventType` only supports saved synthetic Slack input.
-*/
-function isResourceEventConversationMessage(message) {
-	return Boolean(message.meta?.eventType) || message.author?.userId === "UJRNEVENT";
-}
-//#endregion
-//#region src/chat/resource-events/notification.ts
+//#region src/chat/events/notification.ts
 /**
 * Render the runtime-owned conversation message for a subscribed event.
 *
 * Keep this short: facts the model cannot reconstruct, plus a one-line handling
 * contract. Stable delivery rules live in runtime and docs, not this prompt.
 */
-function renderResourceEventNotificationText(subscription, event) {
-	const guidance = resourceEventGuidance(getResourceEventCatalog(), event.namespace, subscription.resourceType, event.eventType);
+function renderEventNotificationText(subscription, event) {
+	const guidance = eventGuidance(getEventCatalog(), event.namespace, subscription.resourceType, event.eventType);
 	return renderTaskInput({
 		about: subscription.label,
 		instructions: subscription.intent,
@@ -2874,21 +2846,21 @@ function renderResourceEventNotificationText(subscription, event) {
 		externalText: event.untrustedText
 	});
 }
-/** Whether mailbox metadata is a plain resource-event wake. */
-function isResourceEventMailboxMetadata(value) {
+/** Whether mailbox metadata is a plain event wake. */
+function isEventMailboxMetadata(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
 	const record = value;
-	if (record.kind !== "resource_event") return false;
-	const resourceEvent = record.resourceEvent;
-	if (!resourceEvent || typeof resourceEvent !== "object" || Array.isArray(resourceEvent)) return false;
-	const fields = resourceEvent;
+	if (record.kind !== "event") return false;
+	const event = record.event;
+	if (!event || typeof event !== "object" || Array.isArray(event)) return false;
+	const fields = event;
 	return typeof fields.eventKey === "string" && typeof fields.eventType === "string" && typeof fields.namespace === "string" && typeof fields.identifier === "string" && typeof fields.subscriptionId === "string" && (fields.trustedSummary === void 0 || typeof fields.trustedSummary === "string");
 }
 /** Build plain conversation mailbox input for one matched watch. */
-function createResourceEventInboundMessage(input) {
+function createEventInboundMessage(input) {
 	const metadata = {
-		kind: "resource_event",
-		resourceEvent: {
+		kind: "event",
+		event: {
 			eventKey: input.event.eventKey,
 			eventType: input.event.eventType,
 			namespace: input.event.namespace,
@@ -2900,25 +2872,25 @@ function createResourceEventInboundMessage(input) {
 	return {
 		conversationId: input.subscription.conversationId,
 		createdAtMs: input.event.occurredAtMs,
-		inboundMessageId: `resource-event:${input.subscription.id}:${input.event.eventKey}`,
+		inboundMessageId: `event:${input.subscription.id}:${input.event.eventKey}`,
 		delivery: "defer",
-		source: "resource_event",
+		source: "event",
 		receivedAtMs: input.receivedAtMs ?? Date.now(),
 		input: {
 			text: input.text,
-			authorId: RESOURCE_EVENT_AUTHOR_ID,
+			authorId: EVENT_AUTHOR_ID,
 			metadata
 		}
 	};
 }
 /**
-* Enqueue a resource event as normal conversation mailbox input.
+* Enqueue a event as normal conversation mailbox input.
 *
 * The watch only names the conversation. Destination stays on the conversation
 * and is applied when the worker runs. After too many automated Turns with no
 * user Turn, later wakes stay quiet until a user message clears the pause.
 */
-async function enqueueResourceEventNotification(args) {
+async function enqueueEventNotification(args) {
 	const maxTurns = botConfig.maxConsecutiveAutomatedTurns;
 	const decision = await admitAutomatedTurn({
 		conversationId: args.subscription.conversationId,
@@ -2927,12 +2899,12 @@ async function enqueueResourceEventNotification(args) {
 		state: args.state
 	});
 	if (decision.status === "paused") {
-		logInfo("resource_events.automated_turn_limit.paused", {
+		logInfo("events.automated_turn_limit.paused", {
 			conversationId: args.subscription.conversationId,
 			"app.automated_turn_limit.consecutive": decision.consecutiveAutomatedTurns,
 			"app.automated_turn_limit.max": maxTurns,
-			"app.resource_event.event_type": args.event.eventType,
-			"app.resource_event.namespace": args.event.namespace
+			"app.event.event_type": args.event.eventType,
+			"app.event.namespace": args.event.namespace
 		});
 		if (decision.shouldPostNotice) await postAutomatedTurnLimitNoticeForConversation({
 			conversationId: args.subscription.conversationId,
@@ -2941,9 +2913,9 @@ async function enqueueResourceEventNotification(args) {
 		});
 		return { status: "duplicate" };
 	}
-	const text = renderResourceEventNotificationText(args.subscription, args.event);
+	const text = renderEventNotificationText(args.subscription, args.event);
 	return await appendAndEnqueueInboundMessage({
-		message: createResourceEventInboundMessage({
+		message: createEventInboundMessage({
 			event: args.event,
 			subscription: {
 				conversationId: args.subscription.conversationId,
@@ -2956,12 +2928,12 @@ async function enqueueResourceEventNotification(args) {
 	});
 }
 //#endregion
-//#region src/chat/resource-events/ingest.ts
-/** Match a normalized resource event and enqueue notifications into conversations. */
-async function ingestResourceEvent(input, options) {
-	const event = resourceEventSchema.parse(input);
+//#region src/chat/events/ingest.ts
+/** Match a normalized event and enqueue notifications into conversations. */
+async function ingestEvent(input, options) {
+	const event = eventSchema.parse(input);
 	const nowMs = options.nowMs ?? Date.now();
-	const subscriptions = await findMatchingResourceEventSubscriptions({
+	const subscriptions = await findMatchingWatches({
 		data: event.data,
 		eventType: event.eventType,
 		nowMs,
@@ -2973,7 +2945,7 @@ async function ingestResourceEvent(input, options) {
 	const errors = [];
 	const waitDeadlineMs = Date.now() + 1e4;
 	for (const subscription of subscriptions) try {
-		if (await deliverResourceEventSubscription({
+		if (await deliverWatch({
 			data: event.data,
 			eventType: event.eventType,
 			namespace: event.namespace,
@@ -2984,7 +2956,7 @@ async function ingestResourceEvent(input, options) {
 			subscription,
 			waitDeadlineMs,
 			deliver: async (current) => {
-				return (await enqueueResourceEventNotification({
+				return (await enqueueEventNotification({
 					event,
 					queue: options.queue,
 					state: options.state,
@@ -2995,7 +2967,7 @@ async function ingestResourceEvent(input, options) {
 	} catch (error) {
 		errors.push(error);
 	}
-	if (errors.length > 0) throw new AggregateError(errors, "Failed to deliver one or more resource event subscriptions");
+	if (errors.length > 0) throw new AggregateError(errors, "Failed to deliver one or more watches");
 	return { enqueued };
 }
 //#endregion
@@ -3391,7 +3363,7 @@ const SNAPSHOT_BUILD_SYSTEM_ACTOR = {
 /** Leave time to send the next job before this request ends. */
 const JOB_STOP_BUFFER_MS = 4e4;
 async function publishFinishedEvent(input) {
-	await ingestResourceEvent(workspaceSnapshotFinishedEvent(input), { queue: getVercelConversationWorkQueue() });
+	await ingestEvent(workspaceSnapshotFinishedEvent(input), { queue: getVercelConversationWorkQueue() });
 }
 function createSnapshotBuildHelpers() {
 	const credentials = credentialContextForActor(SNAPSHOT_BUILD_SYSTEM_ACTOR);
@@ -3405,9 +3377,7 @@ function createSnapshotBuildHelpers() {
 		await sandbox.update({ networkPolicy });
 		return networkPolicy;
 	};
-	const prepareRepositories = async (sandbox, target, signal) => {
-		await pluginHooks.prepareWorkspace(sandbox, target.repos, signal);
-	};
+	const prepareRepositories = async (sandbox, target, signal) => await pluginHooks.prepareWorkspace(sandbox, target.repos, signal);
 	return {
 		applyNetworkPolicy,
 		prepareRepositories
@@ -3917,7 +3887,14 @@ function createSandboxRuntime(options) {
 		let networkPolicyKey;
 		try {
 			networkPolicyKey = await applyNetworkPolicy(createdSandbox);
-			if (workspace) await options.onWorkspacePrepare?.(createdSandbox, workspace, signal);
+			if (workspace) {
+				const finalize = await options.onWorkspacePrepare?.(createdSandbox, workspace, signal);
+				if (options.createNetworkPolicy) {
+					await createdSandbox.update({ networkPolicy: "allow-all" });
+					networkPolicyKey = void 0;
+				}
+				await finalize?.();
+			}
 			await prepareSandbox(createdSandbox);
 		} catch (error) {
 			if (workspace) await stopSession(createdSandbox);
@@ -7174,7 +7151,7 @@ function createSpawnAgentTool(spawnAgent) {
 	});
 }
 //#endregion
-//#region src/chat/tools/list-resource-event-subscriptions.ts
+//#region src/chat/tools/list-watches.ts
 const listedResourceWatchSchema = z.object({
 	id: z.string().min(1),
 	label: z.string().min(1),
@@ -7188,8 +7165,8 @@ const listedResourceWatchSchema = z.object({
 }).strict();
 const resultDataSchema$2 = z.object({ subscriptions: z.array(listedResourceWatchSchema) }).strict();
 const outputSchema$5 = juniorToolOutputSchema.merge(resultDataSchema$2);
-/** Create the tool that lists active resource watches for this conversation. */
-function createListResourceEventSubscriptionsTool(context) {
+/** Create the tool that lists active watches for this conversation. */
+function createListWatchesTool(context) {
 	return zodTool({
 		annotations: {
 			destructiveHint: false,
@@ -7197,13 +7174,13 @@ function createListResourceEventSubscriptionsTool(context) {
 			openWorldHint: false,
 			readOnlyHint: true
 		},
-		description: "List active resource event subscriptions for the current conversation.",
+		description: "List active watches for the current conversation.",
 		exposure: "deferred",
 		source: RESOURCE_WATCH_TOOL_SOURCE,
 		inputSchema: z.object({}).strict(),
 		outputSchema: outputSchema$5,
 		async execute() {
-			return { subscriptions: (await listResourceEventSubscriptions({ conversationId: context.conversationId })).map((subscription) => ({
+			return { subscriptions: (await listWatches({ conversationId: context.conversationId })).map((subscription) => ({
 				id: subscription.id,
 				label: subscription.label,
 				identifier: subscription.identifier,
@@ -7218,7 +7195,7 @@ function createListResourceEventSubscriptionsTool(context) {
 	});
 }
 //#endregion
-//#region src/chat/tools/search-resource-event-types.ts
+//#region src/chat/tools/search-event-types.ts
 const DEFAULT_SEARCH_RESULTS = 10;
 const MAX_SEARCH_RESULTS = 20;
 const searchedResourceTypeSchema = z.object({
@@ -7254,8 +7231,8 @@ function searchableResourceTypes(catalog) {
 		...resourceType.matchFields ? { matchFields: resourceType.matchFields } : void 0
 	}))).sort((left, right) => left.namespace.localeCompare(right.namespace) || left.type.localeCompare(right.type));
 }
-/** Create the read-only tool that searches enabled resource event types. */
-function createSearchResourceEventTypesTool(catalog) {
+/** Create the read-only tool that searches enabled event types. */
+function createSearchEventTypesTool(catalog) {
 	return zodTool({
 		annotations: {
 			destructiveHint: false,
@@ -7263,9 +7240,9 @@ function createSearchResourceEventTypesTool(catalog) {
 			openWorldHint: false,
 			readOnlyHint: true
 		},
-		description: "Search the resource event types currently enabled without creating anything. Includes plugin resources and core Workspace snapshot events. Use watchResourceEvents for temporary updates in the current conversation; use createEventTask for durable automation. This tool does not watch a resource, create a task, or list concrete resources.",
+		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.",
 		inputSchema: z.object({
-			query: z.string().nullable().describe("Optional terms matching a namespace, resource type, or event name. Empty lists all enabled resource event types.").optional(),
+			query: z.string().nullable().describe("Optional terms matching a namespace, resource type, or event name. Empty lists all enabled event types.").optional(),
 			namespace: eventNamespaceSchema(catalog).nullable().describe("Optional enabled plugin namespace to search within.").optional(),
 			maxResults: z.number().int().min(1).max(MAX_SEARCH_RESULTS).nullable().describe("Maximum matching resource types to return.").optional()
 		}).strict(),
@@ -7294,13 +7271,13 @@ function createSearchResourceEventTypesTool(catalog) {
 	});
 }
 //#endregion
-//#region src/chat/tools/stop-watching-resources.ts
+//#region src/chat/tools/stop-watches.ts
 const resultDataSchema$1 = z.object({
 	watching_status: z.literal("stopped"),
 	stoppedIds: z.array(z.string().min(1))
 }).strict();
 const outputSchema$3 = juniorToolOutputSchema.merge(resultDataSchema$1);
-/** Create the tool that stops resource watches for this conversation. */
+/** Create the tool that stops watches for this conversation. */
 function createStopWatchingResourcesTool(context) {
 	return zodTool({
 		annotations: {
@@ -7309,7 +7286,7 @@ function createStopWatchingResourcesTool(context) {
 			openWorldHint: false,
 			readOnlyHint: false
 		},
-		description: "Stop one resource watch in the current conversation by id. Omit id only when the user explicitly asks to stop every watch in this conversation. Infer terse stop requests from context, inspect active watches when the target is unclear, and call this tool before confirming that watching stopped.",
+		description: "Stop one watch in the current conversation by id. Omit id only when the user explicitly asks to stop every watch in this conversation. Infer terse stop requests from context, inspect active watches when the target is unclear, and call this tool before confirming that watching stopped.",
 		exposure: "deferred",
 		source: RESOURCE_WATCH_TOOL_SOURCE,
 		inputSchema: z.object({ id: z.string().min(1).nullable().optional() }).strict(),
@@ -7317,14 +7294,14 @@ function createStopWatchingResourcesTool(context) {
 		async execute({ id }) {
 			let stoppedIds;
 			if (id) {
-				const stopped = await cancelResourceEventSubscription({
+				const stopped = await cancelWatch({
 					conversationId: context.conversationId,
 					id
 				});
-				if (!stopped) throw new ToolInputError("Resource watch was not found in the current conversation.");
+				if (!stopped) throw new ToolInputError("Watch was not found in the current conversation.");
 				stoppedIds = [stopped.id];
 			} else {
-				const subscriptions = await listResourceEventSubscriptions({ conversationId: context.conversationId });
+				const subscriptions = await listWatches({ conversationId: context.conversationId });
 				await cancelSubscriptions({ conversationId: context.conversationId });
 				stoppedIds = subscriptions.map((subscription) => subscription.id);
 			}
@@ -7336,7 +7313,7 @@ function createStopWatchingResourcesTool(context) {
 	});
 }
 //#endregion
-//#region src/chat/tools/watch-resource-events.ts
+//#region src/chat/tools/watch-events.ts
 function inputSchema(catalog) {
 	return z.object({
 		identifier: z.string().trim().min(1).describe("Plugin-defined resource identifier."),
@@ -7344,7 +7321,7 @@ function inputSchema(catalog) {
 		resourceType: registeredResourceTypeSchema(catalog).describe("Plugin-defined resource type."),
 		label: z.string().trim().min(1).max(500).describe("Human-readable resource label."),
 		events: z.array(registeredEventTypeSchema(catalog)).min(1).describe("High-signal event names to deliver to this conversation when they occur."),
-		match: registeredResourceEventMatchSchema(),
+		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) => {
@@ -7384,11 +7361,11 @@ function cleanStrings(values) {
 function ttlMs(input) {
 	if (input.ttlMs === void 0) return RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS;
 	if (!Number.isFinite(input.ttlMs) || input.ttlMs <= 0) throw new ToolInputError("ttlMs must be a positive finite number");
-	if (input.ttlMs > 2592e6) throw new ToolInputError("Resource watches cannot exceed 30 days");
+	if (input.ttlMs > 2592e6) throw new ToolInputError("Watches cannot exceed 30 days");
 	return input.ttlMs;
 }
-/** Create the tool that temporarily watches resource events in one conversation. */
-function createWatchResourceEventsTool(context, catalog) {
+/** Create the tool that temporarily watches events in one conversation. */
+function createWatchEventsTool(context, catalog) {
 	return zodTool({
 		annotations: {
 			destructiveHint: false,
@@ -7396,7 +7373,7 @@ function createWatchResourceEventsTool(context, catalog) {
 			openWorldHint: true,
 			readOnlyHint: false
 		},
-		description: "Watch one plugin resource in the current conversation for a limited time; matching events return to this conversation as updates. Use for watch, notify, or tell-me-when requests. This does not create an event task or execute a durable task instruction. Prefer a subscribable tool result when available.",
+		description: "Watch one plugin resource in the current conversation for a limited time; matching events return to this conversation as updates. Use for watch, notify, or tell-me-when requests. This does not create an event automation or execute a durable automation instruction. Prefer a subscribable tool result when available.",
 		inputSchema: inputSchema(catalog),
 		outputSchema: outputSchema$2,
 		async execute(input) {
@@ -7404,13 +7381,13 @@ function createWatchResourceEventsTool(context, catalog) {
 			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 = requireSupportedResourceEventMatch(catalog, {
+			const match = requireSupportedEventMatch(catalog, {
 				match: input.match,
 				namespace: input.namespace,
 				resourceType: input.resourceType
 			});
 			const nowMs = Date.now();
-			const subscription = await createResourceEventSubscription({
+			const subscription = await createWatch({
 				conversationId: context.conversationId,
 				events,
 				expiresAtMs: nowMs + ttlMs(input),
@@ -7418,7 +7395,7 @@ function createWatchResourceEventsTool(context, catalog) {
 				label: input.label.trim(),
 				...match ? { match } : void 0,
 				namespace: input.namespace.trim(),
-				identifier: normalizeEventIdentifier(catalog, input.namespace, input.identifier),
+				identifier: normalizeCatalogEventIdentifier(catalog, input.namespace, input.identifier),
 				resourceType: input.resourceType.trim()
 			});
 			return {
@@ -7440,24 +7417,24 @@ function createWatchResourceEventsTool(context, catalog) {
 	});
 }
 //#endregion
-//#region src/chat/tools/resource-events.ts
+//#region src/chat/tools/events.ts
 /** Build the complete resource-watch tool set for this runtime context. */
-function createResourceEventTools(context, catalog) {
+function createEventTools(context, catalog) {
 	return {
-		...hasResourceEventCatalogEntries(catalog) ? {
-			searchResourceEventTypes: createSearchResourceEventTypesTool(catalog),
-			watchResourceEvents: createWatchResourceEventsTool(context, catalog)
+		...hasEventCatalogEntries(catalog) ? {
+			searchEventTypes: createSearchEventTypesTool(catalog),
+			watchEvents: createWatchEventsTool(context, catalog)
 		} : void 0,
-		listResourceEventSubscriptions: createListResourceEventSubscriptionsTool(context),
+		listWatches: createListWatchesTool(context),
 		stopWatchingResources: createStopWatchingResourcesTool(context)
 	};
 }
 //#endregion
-//#region src/chat/tools/create-event-task.ts
-/** Build a retry-stable task id scoped to actor, destination, and tool call. */
-function buildEventTaskId(args) {
+//#region src/chat/tools/create-event-automation.ts
+/** Build a retry-stable automation id scoped to actor, destination, and tool call. */
+function buildEventAutomationId(args) {
 	const toolCallId = args.toolCallId?.trim();
-	if (!toolCallId) throw new Error("Event task creation requires a tool-call identity.");
+	if (!toolCallId) throw new Error("Event automation creation requires a tool-call identity.");
 	return `evt_${createHash("sha256").update(JSON.stringify({
 		actor: args.userId,
 		channel: args.channelId,
@@ -7465,9 +7442,9 @@ function buildEventTaskId(args) {
 		team: args.teamId
 	})).digest("hex").slice(0, 32)}`;
 }
-/** Create the core tool that stores an event task. */
-function createEventTaskTool(context, catalog) {
-	const trigger = registeredEventTaskTriggerSchema(catalog);
+/** Create the core tool that stores an event automation. */
+function createEventAutomationTool(context, catalog) {
+	const trigger = registeredEventAutomationTriggerSchema(catalog);
 	return zodTool({
 		approvalMode: "review",
 		annotations: {
@@ -7477,12 +7454,12 @@ function createEventTaskTool(context, catalog) {
 			readOnlyHint: false
 		},
 		executionMode: "sequential",
-		description: "Create a durable event task that executes the supplied instruction for every matching resource event. Use for whenever-this-happens-do-X automation; ordinary watch, notify, or tell-me-when requests use watchResourceEvents instead. The task may use the creator's connected credentials. Prefer a subscribable tool result when available.",
+		description: "Create a durable event automation that 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.",
 		inputSchema: z.object({
-			task: z.string().trim().min(1).max(4e3),
+			instruction: z.string().trim().min(1).max(4e3),
 			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(),
 			trigger,
-			outcomes: z.array(taskOutcomeInputSchema).max(5).describe("Messages to send after successful work. Use an empty list to send nothing. Omit to send one message to the current Slack conversation.").optional(),
+			outcomes: z.array(taskOutcomeInputSchema).max(5).describe("Successful work is silent by default. Omit this field or use an empty list when the Automation should act through tools without a status message. Add send_message only when the user asks for a notification, post, digest, summary, or other visible result.").optional(),
 			credentialMode: z.enum(["creator", "system"]).nullable().describe("Use creator to make the task creator's connected credentials available, or system when the creator says not to use them. Omit or use null for the creator default.").optional()
 		}).strict(),
 		prepareArguments(args) {
@@ -7491,25 +7468,25 @@ function createEventTaskTool(context, catalog) {
 			if (prepared.credentialMode === "creator" || prepared.credentialMode === null) delete prepared.credentialMode;
 			return prepared;
 		},
-		outputSchema: eventTaskToolResultSchema,
+		outputSchema: eventAutomationToolResultSchema,
 		async execute(input, options) {
-			const { actor, destination, source } = requireEventTaskSlackContext(context);
-			const match = requireSupportedEventTaskTrigger(catalog, input.trigger);
-			const id = buildEventTaskId({
+			const { actor, destination, source } = requireEventAutomationSlackContext(context);
+			const match = requireSupportedEventAutomationTrigger(catalog, input.trigger);
+			const id = buildEventAutomationId({
 				channelId: destination.channelId,
 				teamId: destination.teamId,
 				toolCallId: options.toolCallId,
 				userId: actor.userId
 			});
 			const db = getDb();
-			const existing = await getEventTask(db, id);
+			const existing = await getEventAutomation(db, id);
 			if (existing) {
-				if (!eventTaskMatchesDestination(existing, destination) || existing.createdBy.slackUserId !== actor.userId) throw new ToolInputError("Event task operation identity is invalid.");
-				if (existing.status !== "deleted") return eventTaskSuccess(existing, catalog);
+				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);
 			}
 			const title = await resolveTaskTitle({
 				completeText,
-				instruction: input.task,
+				instruction: input.instruction,
 				title: input.title
 			});
 			const task = {
@@ -7524,25 +7501,25 @@ function createEventTaskTool(context, catalog) {
 				credentialMode: input.credentialMode ?? "creator",
 				destination,
 				outcomes: await resolveTaskOutcomes(input.outcomes, destination, actor.userId),
-				task: { text: input.task },
+				task: { text: input.instruction },
 				...title ? { title } : void 0,
 				trigger: {
 					namespace: input.trigger.namespace,
-					identifier: normalizeEventIdentifier(catalog, input.trigger.namespace, input.trigger.identifier),
+					identifier: normalizeCatalogEventIdentifier(catalog, input.trigger.namespace, input.trigger.identifier),
 					resourceType: input.trigger.resourceType,
 					label: input.trigger.label,
 					events: [...new Set(input.trigger.events)],
 					...match ? { match } : void 0
 				}
 			};
-			return eventTaskSuccess(await createEventTask(db, task), catalog);
+			return eventAutomationToolResult(await createEventAutomation(db, task), catalog, actor.userId);
 		}
 	});
 }
 //#endregion
-//#region src/chat/tools/delete-event-task.ts
-/** Create the core tool that deletes an event task. */
-function createDeleteEventTaskTool(context, catalog) {
+//#region src/chat/tools/delete-event-automation.ts
+/** Create the core tool that deletes an event automation. */
+function createDeleteEventAutomationTool(context, catalog) {
 	return zodTool({
 		approvalMode: "review",
 		annotations: {
@@ -7552,22 +7529,23 @@ function createDeleteEventTaskTool(context, catalog) {
 			readOnlyHint: false
 		},
 		executionMode: "sequential",
-		description: "Delete an event task.",
-		inputSchema: z.object({ taskId: z.string().min(1) }).strict(),
-		outputSchema: eventTaskToolResultSchema,
-		async execute({ taskId }) {
-			const current = await writableEventTask(context, taskId);
-			const deleted = await deleteEventTask(getDb(), current.id);
-			if (!deleted) throw new ToolInputError("Event task was not found.");
-			return eventTaskSuccess(deleted, catalog);
+		description: "Delete an event automation.",
+		inputSchema: z.object({ automationId: z.string().min(1) }).strict(),
+		outputSchema: eventAutomationToolResultSchema,
+		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 eventAutomationToolResult(deleted, catalog, actor.userId);
 		}
 	});
 }
 //#endregion
-//#region src/chat/tools/list-event-tasks.ts
-const MAX_LISTED_EVENT_TASKS = 50;
-/** Create the core tool that lists event tasks for this destination. */
-function createListEventTasksTool(context, catalog) {
+//#region src/chat/tools/list-event-automations.ts
+const MAX_LISTED_EVENT_AUTOMATIONS = 50;
+/** Create the core tool that lists event automations for this destination. */
+function createListEventAutomationsTool(context, catalog) {
 	return zodTool({
 		annotations: {
 			destructiveHint: false,
@@ -7575,30 +7553,30 @@ function createListEventTasksTool(context, catalog) {
 			openWorldHint: false,
 			readOnlyHint: true
 		},
-		description: "List event tasks for the current destination. A false triggerAvailable value means the task remains stored but its plugin event is not currently enabled.",
+		description: "List event automations for the current destination. Each result says whether the requester is the creator and whether its trigger is available.",
 		inputSchema: z.object({}).strict(),
-		outputSchema: eventTaskListToolResultSchema,
+		outputSchema: eventAutomationListToolResultSchema,
 		async execute() {
-			const { destination } = requireEventTaskSlackContext(context);
-			const matching = (await listEventTasksForTeam(getDb(), destination.teamId)).filter((task) => eventTaskMatchesDestination(task, destination));
-			const tasks = matching.slice(0, MAX_LISTED_EVENT_TASKS).map((task) => compactEventTask(task, catalog));
+			const { actor, destination } = requireEventAutomationSlackContext(context);
+			const matching = (await listEventAutomationsForTeam(getDb(), destination.teamId)).filter((task) => eventAutomationMatchesDestination(task, destination));
+			const automations = matching.slice(0, MAX_LISTED_EVENT_AUTOMATIONS).map((task) => compactEventAutomation(task, catalog, actor.userId));
 			return {
-				tasks,
-				truncated: matching.length > tasks.length
+				automations,
+				truncated: matching.length > automations.length
 			};
 		}
 	});
 }
 //#endregion
-//#region src/chat/tools/update-event-task.ts
+//#region src/chat/tools/update-event-automation.ts
 /** Return whether an edit changes the task's executable event source. */
-function changesEventTaskTrigger(current, next) {
+function changesEventAutomationTrigger(current, next) {
 	const currentEvents = [...current.events].sort();
 	const nextEvents = [...next.events].sort();
-	return current.namespace !== next.namespace || current.identifier !== next.identifier || currentEvents.length !== nextEvents.length || currentEvents.some((event, index) => event !== nextEvents[index]) || stableResourceEventMatchKey(current.match) !== stableResourceEventMatchKey(next.match);
+	return current.namespace !== next.namespace || current.identifier !== next.identifier || currentEvents.length !== nextEvents.length || currentEvents.some((event, index) => event !== nextEvents[index]) || stableEventMatchKey(current.match) !== stableEventMatchKey(next.match);
 }
-/** Create the core tool that updates an event task. */
-function createUpdateEventTaskTool(context, catalog) {
+/** Create the core tool that updates an event automation. */
+function createUpdateEventAutomationTool(context, catalog) {
 	return zodTool({
 		approvalMode: "review",
 		annotations: {
@@ -7608,44 +7586,44 @@ function createUpdateEventTaskTool(context, catalog) {
 			readOnlyHint: false
 		},
 		executionMode: "sequential",
-		description: "Update the instruction, registered trigger, or credential use for an event task.",
+		description: "Update the instruction, registered trigger, or credential use for an event automation.",
 		inputSchema: z.object({
-			taskId: z.string().min(1),
-			task: z.string().trim().min(1).max(4e3).nullable().optional(),
-			trigger: registeredEventTaskTriggerSchema(catalog).nullable().optional(),
+			automationId: z.string().min(1),
+			instruction: z.string().trim().min(1).max(4e3).nullable().optional(),
+			trigger: registeredEventAutomationTriggerSchema(catalog).nullable().optional(),
 			outcomes: z.array(taskOutcomeInputSchema).max(5).nullable().describe("Replacement messages to send after successful work. Use an empty list to send nothing. Omit or use null to leave unchanged.").optional(),
 			credentialMode: z.enum(["system", "creator"]).nullable().describe("Set creator to make the task's original creator credentials available, or system to disable them. Creator always means the task's createdBy actor, never the current requester. Only that original creator may enable creator mode. Omit or use null to leave unchanged.").optional()
 		}).strict(),
 		prepareArguments(args) {
-			const { credentialMode, outcomes, task, trigger, ...prepared } = args;
+			const { credentialMode, outcomes, instruction, trigger, ...prepared } = args;
 			return {
 				...prepared,
-				...task != null ? { task } : void 0,
+				...instruction != null ? { instruction } : void 0,
 				...trigger != null ? { trigger } : void 0,
 				...outcomes != null ? { outcomes } : void 0,
 				...credentialMode != null ? { credentialMode } : void 0
 			};
 		},
-		outputSchema: eventTaskToolResultSchema,
+		outputSchema: eventAutomationToolResultSchema,
 		async execute(input) {
-			const current = await writableEventTask(context, input.taskId);
-			const match = input.trigger ? requireSupportedEventTaskTrigger(catalog, input.trigger) : void 0;
-			const { actor } = requireEventTaskSlackContext(context);
+			const current = await writableEventAutomation(context, input.automationId);
+			const match = input.trigger ? requireSupportedEventAutomationTrigger(catalog, input.trigger) : void 0;
+			const { actor } = requireEventAutomationSlackContext(context);
 			const isCreator = actor.userId === current.createdBy.slackUserId;
-			if (input.credentialMode === "creator" && !isCreator) throw new ToolInputError("Only the event task creator can enable creator credential use.");
-			if (input.outcomes != null && !isCreator) throw new ToolInputError("Only the event task creator can change message destinations.");
-			if (input.task === void 0 && input.trigger === void 0 && input.outcomes == null && input.credentialMode == null) throw new ToolInputError("Event task update requires a change.");
+			if (input.credentialMode === "creator" && !isCreator) throw new ToolInputError("Only the event automation creator can enable creator credential use.");
+			if (input.outcomes != null && !isCreator) throw new ToolInputError("Only the event automation creator can change message destinations.");
+			if (input.instruction === void 0 && input.trigger === void 0 && input.outcomes == null && input.credentialMode == null) throw new ToolInputError("Event automation update requires a change.");
 			const nextTrigger = input.trigger ? {
 				namespace: input.trigger.namespace,
-				identifier: normalizeEventIdentifier(catalog, input.trigger.namespace, input.trigger.identifier),
+				identifier: normalizeCatalogEventIdentifier(catalog, input.trigger.namespace, input.trigger.identifier),
 				resourceType: input.trigger.resourceType,
 				label: input.trigger.label,
 				events: [...new Set(input.trigger.events)],
 				...match ? { match } : void 0
 			} : current.trigger;
-			const nextInstruction = input.task != null ? input.task : current.task.text;
+			const nextInstruction = input.instruction != null ? input.instruction : current.task.text;
 			const instructionChanged = nextInstruction !== current.task.text;
-			const changesExecution = instructionChanged || changesEventTaskTrigger(current.trigger, nextTrigger);
+			const changesExecution = instructionChanged || changesEventAutomationTrigger(current.trigger, nextTrigger);
 			const next = {
 				...current,
 				credentialMode: changesExecution && !isCreator ? "system" : input.credentialMode ?? current.credentialMode,
@@ -7662,26 +7640,26 @@ function createUpdateEventTaskTool(context, catalog) {
 				if (title) next.title = title;
 				else delete next.title;
 			}
-			const saved = await saveEventTask(getDb(), next);
-			if (!saved) throw new ToolInputError("Event task was not found.");
-			return eventTaskSuccess(saved, catalog);
+			const saved = await saveEventAutomation(getDb(), next);
+			if (!saved) throw new ToolInputError("Event automation was not found.");
+			return eventAutomationToolResult(saved, catalog, actor.userId);
 		}
 	});
 }
 //#endregion
-//#region src/chat/tools/event-tasks.ts
-/** Build event task tools for an interactive Slack actor. */
-function createEventTaskTools(context, catalog) {
+//#region src/chat/tools/event-automations.ts
+/** Build event automation tools for an interactive Slack actor. */
+function createEventAutomationTools(context, catalog) {
 	if (context.source.kind !== "slack" || context.destination.platform !== "slack" || context.actor?.platform !== "slack") return {};
 	return {
-		...hasPluginResourceEventCatalogEntries(catalog) ? { createEventTask: createEventTaskTool(context, catalog) } : void 0,
-		listEventTasks: createListEventTasksTool(context, catalog),
-		updateEventTask: createUpdateEventTaskTool(context, catalog),
-		deleteEventTask: createDeleteEventTaskTool(context, catalog)
+		...hasPluginEventCatalogEntries(catalog) ? { createEventAutomation: createEventAutomationTool(context, catalog) } : void 0,
+		listEventAutomations: createListEventAutomationsTool(context, catalog),
+		updateEventAutomation: createUpdateEventAutomationTool(context, catalog),
+		deleteEventAutomation: createDeleteEventAutomationTool(context, catalog)
 	};
 }
 //#endregion
-//#region src/chat/scheduled-tasks/cadence.ts
+//#region src/chat/scheduled-automations/cadence.ts
 const FORMATTERS = /* @__PURE__ */ new Map();
 function getFormatter(timezone) {
 	const existing = FORMATTERS.get(timezone);
@@ -7924,7 +7902,7 @@ function getNextRunAtMs(task, scheduledForMs, afterMs = scheduledForMs) {
 	});
 }
 //#endregion
-//#region src/chat/scheduled-tasks/schedule-intent.ts
+//#region src/chat/scheduled-automations/schedule-intent.ts
 /**
 * Owns model-facing schedule intent and materializes it against the trusted
 * server clock into the canonical schedule persisted by core.
@@ -7971,9 +7949,9 @@ const recurringScheduleIntentSchema = z.object({
 	interval: z.number().int().positive().max(365).describe("Repeat every N frequency units. Defaults to 1.").nullable().optional(),
 	time: localTimeSchema.describe("Local wall-clock time for each occurrence in HH:MM format."),
 	weekdays: z.array(weekdaySchema).min(1).max(7).describe("Required for weekly schedules.").nullable().optional(),
-	day_of_month: z.number().int().min(1).max(31).describe("Required for monthly and yearly schedules.").nullable().optional(),
+	dayOfMonth: z.number().int().min(1).max(31).describe("Required for monthly and yearly schedules.").nullable().optional(),
 	month: z.number().int().min(1).max(12).describe("Required for yearly schedules, where January is 1.").nullable().optional(),
-	start_date: localDateSchema.describe("Optional local calendar date that anchors the recurrence. Omit to start with the next matching occurrence.").nullable().optional(),
+	startDate: localDateSchema.describe("Optional local calendar date that anchors the recurrence. Omit to start with the next matching occurrence.").nullable().optional(),
 	timezone: timezoneSchema
 }).strict().superRefine((schedule, context) => {
 	if (schedule.frequency === "weekly" && schedule.weekdays == null) context.addIssue({
@@ -7981,10 +7959,10 @@ const recurringScheduleIntentSchema = z.object({
 		message: "Weekly schedules require weekdays.",
 		path: ["weekdays"]
 	});
-	if ((schedule.frequency === "monthly" || schedule.frequency === "yearly") && schedule.day_of_month == null) context.addIssue({
+	if ((schedule.frequency === "monthly" || schedule.frequency === "yearly") && schedule.dayOfMonth == null) context.addIssue({
 		code: "custom",
-		message: `${schedule.frequency} schedules require day_of_month.`,
-		path: ["day_of_month"]
+		message: `${schedule.frequency} schedules require dayOfMonth.`,
+		path: ["dayOfMonth"]
 	});
 	if (schedule.frequency === "yearly" && schedule.month == null) context.addIssue({
 		code: "custom",
@@ -7996,10 +7974,10 @@ const recurringScheduleIntentSchema = z.object({
 		message: "weekdays applies only to weekly schedules.",
 		path: ["weekdays"]
 	});
-	if (schedule.frequency !== "monthly" && schedule.frequency !== "yearly" && schedule.day_of_month != null) context.addIssue({
+	if (schedule.frequency !== "monthly" && schedule.frequency !== "yearly" && schedule.dayOfMonth != null) context.addIssue({
 		code: "custom",
-		message: "day_of_month applies only to monthly or yearly schedules.",
-		path: ["day_of_month"]
+		message: "dayOfMonth applies only to monthly or yearly schedules.",
+		path: ["dayOfMonth"]
 	});
 	if (schedule.frequency !== "yearly" && schedule.month != null) context.addIssue({
 		code: "custom",
@@ -8066,8 +8044,8 @@ function recurringDescription(schedule, timezone) {
 	const cadence = interval === 1 ? cadenceUnit : `${interval} ${cadenceUnit}s`;
 	let detail = "";
 	if (schedule.frequency === "weekly") detail = ` on ${formatWeekdays(schedule.weekdays)}`;
-	else if (schedule.frequency === "monthly") detail = ` on day ${schedule.day_of_month}`;
-	else if (schedule.frequency === "yearly") detail = ` on ${String(schedule.month).padStart(2, "0")}-${String(schedule.day_of_month).padStart(2, "0")}`;
+	else if (schedule.frequency === "monthly") detail = ` on day ${schedule.dayOfMonth}`;
+	else if (schedule.frequency === "yearly") detail = ` on ${String(schedule.month).padStart(2, "0")}-${String(schedule.dayOfMonth).padStart(2, "0")}`;
 	return `Every ${cadence}${detail} at ${schedule.time} (${timezone})`;
 }
 var ScheduleIntentError = class extends Error {};
@@ -8103,13 +8081,13 @@ function compileScheduleIntent(args) {
 	const recurrence = {
 		frequency: args.intent.frequency,
 		interval: args.intent.interval ?? 1,
-		startDate: args.intent.start_date ?? localDateAt(args.nowMs, timezone),
+		startDate: args.intent.startDate ?? localDateAt(args.nowMs, timezone),
 		time: parseLocalTime(args.intent.time),
 		...args.intent.frequency === "weekly" ? { weekdays: [...new Set(args.intent.weekdays.map((weekday) => WEEKDAY_INDEX[weekday]))].sort((left, right) => left - right) } : void 0,
-		...args.intent.frequency === "monthly" || args.intent.frequency === "yearly" ? { dayOfMonth: args.intent.day_of_month ?? void 0 } : void 0,
+		...args.intent.frequency === "monthly" || args.intent.frequency === "yearly" ? { dayOfMonth: args.intent.dayOfMonth ?? void 0 } : void 0,
 		...args.intent.frequency === "yearly" ? { month: args.intent.month ?? void 0 } : void 0
 	};
-	const searchRecurrence = args.intent.start_date ? recurrence : {
+	const searchRecurrence = args.intent.startDate ? recurrence : {
 		...recurrence,
 		interval: 1
 	};
@@ -8119,7 +8097,7 @@ function compileScheduleIntent(args) {
 		timezone
 	});
 	if (nextRunAtMs === void 0) throw new ScheduleIntentError("The recurring schedule has no valid future occurrence.");
-	const materializedRecurrence = args.intent.start_date ? recurrence : {
+	const materializedRecurrence = args.intent.startDate ? recurrence : {
 		...recurrence,
 		startDate: localDateAt(nextRunAtMs, timezone)
 	};
@@ -8134,10 +8112,10 @@ function compileScheduleIntent(args) {
 	};
 }
 //#endregion
-//#region src/chat/scheduled-tasks/telemetry.ts
-/** Safe structured telemetry attributes for scheduled-task lifecycle events. */
-/** Correlation attributes shared by scheduled-task create and run events. */
-function scheduledTaskAttributes(task, extras = {}) {
+//#region src/chat/scheduled-automations/telemetry.ts
+/** Safe structured telemetry attributes for scheduled-automation lifecycle events. */
+/** Correlation attributes shared by scheduled-automation create and run events. */
+function scheduledAutomationAttributes(task, extras = {}) {
 	return {
 		"app.task.id": task.id,
 		"app.task.type": "scheduled",
@@ -8154,9 +8132,9 @@ function scheduledTaskAttributes(task, extras = {}) {
 		...extras
 	};
 }
-/** Correlation attributes for one scheduled-task run transition. */
-function scheduledTaskRunAttributes(task, run, extras = {}) {
-	return scheduledTaskAttributes(task, {
+/** Correlation attributes for one scheduled-automation run transition. */
+function scheduledAutomationRunAttributes(task, run, extras = {}) {
+	return scheduledAutomationAttributes(task, {
 		"app.task.run.id": run.id,
 		"app.task.run.status": run.status,
 		"app.task.run.scheduled_for": new Date(run.scheduledForMs).toISOString(),
@@ -8165,12 +8143,12 @@ function scheduledTaskRunAttributes(task, run, extras = {}) {
 		...extras
 	});
 }
-/** Emit the lifecycle event for one skipped scheduled-task run. */
-function logScheduledTaskRunSkipped(task, run, extras = {}) {
-	logInfo("scheduled_task.run.skipped", scheduledTaskRunAttributes(task, run, extras));
+/** Emit the lifecycle event for one skipped scheduled-automation run. */
+function logScheduledAutomationRunSkipped(task, run, extras = {}) {
+	logInfo("scheduled_automation.run.skipped", scheduledAutomationRunAttributes(task, run, extras));
 }
 //#endregion
-//#region src/chat/scheduled-tasks/identity.ts
+//#region src/chat/scheduled-automations/identity.ts
 const SLACK_USER_ID_PATTERN = /^[UW][A-Z0-9]{5,}$/;
 function clean(value) {
 	const normalized = value?.trim();
@@ -8186,9 +8164,9 @@ function cleanDisplay(value, slackUserId) {
 	return SLACK_USER_ID_PATTERN.test(normalized) ? void 0 : normalized;
 }
 /** Keep scheduler creator metadata from promoting Slack IDs into display names. */
-function sanitizeScheduledTaskPrincipal(principal) {
+function sanitizeScheduledAutomationPrincipal(principal) {
 	const slackUserId = cleanSlackUserId(principal.slackUserId);
-	if (!slackUserId) throw new Error("Scheduled task principal requires a Slack user id");
+	if (!slackUserId) throw new Error("Scheduled automation principal requires a Slack user id");
 	const fullName = cleanDisplay(principal.fullName, slackUserId);
 	const userName = cleanDisplay(principal.userName, slackUserId);
 	return {
@@ -8198,28 +8176,32 @@ function sanitizeScheduledTaskPrincipal(principal) {
 	};
 }
 //#endregion
-//#region src/chat/scheduled-tasks/tool-support.ts
+//#region src/chat/scheduled-automations/tool-support.ts
 const TASK_ID_PREFIX = "sched";
 const DEFAULT_SCHEDULE_TIMEZONE = "America/Los_Angeles";
 const compactTaskResultSchema = z.object({
 	id: z.string(),
+	title: z.string().nullable(),
 	status: z.enum([
 		"active",
 		"blocked",
 		"completed",
 		"deleted"
 	]),
-	task: z.string(),
+	statusReason: z.string().nullable(),
+	createdAt: z.string().datetime(),
+	updatedAt: z.string().datetime(),
+	originalRequest: z.string().nullable(),
+	instruction: z.string(),
 	schedule: z.string(),
 	timezone: z.string(),
 	recurrence: z.unknown().nullable(),
-	next_run_at: z.string().nullable(),
+	nextRunAt: z.string().nullable(),
 	destination: z.object({
-		platform: z.literal("slack"),
-		team_id: z.string().min(1),
-		channel_id: z.string().min(1)
+		channel: z.string().min(1),
+		thread: z.string().min(1).nullable()
 	}).strict(),
-	conversation_access: z.object({
+	conversationAccess: z.object({
 		audience: z.enum([
 			"direct",
 			"group",
@@ -8227,22 +8209,29 @@ const compactTaskResultSchema = z.object({
 		]),
 		visibility: z.enum(["private", "public"])
 	}).strict(),
-	credential_mode: z.enum(["system", "creator"]),
-	outcomes: z.array(taskOutcomeSchema).max(5),
-	dashboard_url: z.string().url().nullable(),
-	last_run_at: z.string().nullable(),
-	run_now_at: z.string().nullable()
-}).strict();
-const scheduleTaskToolResultSchema = juniorToolOutputSchema.extend({
-	target: z.string(),
-	task: compactTaskResultSchema
+	credentialMode: z.enum(["system", "creator"]),
+	isCreator: z.boolean(),
+	createdBy: z.object({
+		name: z.string().min(1).nullable(),
+		username: z.string().min(1).nullable()
+	}).strict(),
+	outcomes: z.array(z.object({
+		action: z.literal("send_message"),
+		destination: z.object({
+			channel: z.string().min(1),
+			thread: z.string().min(1).nullable()
+		}).strict()
+	}).strict()).max(5),
+	dashboardUrl: z.string().url().nullable(),
+	lastRunAt: z.string().nullable(),
+	runNowAt: z.string().nullable()
 }).strict();
+const scheduleAutomationToolResultSchema = juniorToolOutputSchema.extend({ automation: compactTaskResultSchema }).strict();
 const scheduleListToolResultSchema = juniorToolOutputSchema.extend({
-	target: z.string(),
-	tasks: z.array(compactTaskResultSchema),
+	automations: z.array(compactTaskResultSchema),
 	truncated: z.boolean()
 }).strict();
-/** Normalize scheduled-task validation failures into the core tool contract. */
+/** Normalize scheduled-automation validation failures into the core tool contract. */
 function throwToolInputError(error) {
 	throw new ToolInputError(error);
 }
@@ -8271,7 +8260,7 @@ function requireActor(context, destination) {
 	if (context.actor?.platform !== "slack" || context.actor.teamId !== destination.teamId) throwToolInputError("No active Slack actor context is available.");
 	const userId = context.actor?.userId?.trim();
 	if (!userId || userId.toLowerCase() === "unknown") throwToolInputError("No active Slack actor context is available.");
-	return sanitizeScheduledTaskPrincipal({
+	return sanitizeScheduledAutomationPrincipal({
 		slackUserId: userId,
 		...context.actor?.userName ? { userName: context.actor.userName } : void 0,
 		...context.actor?.fullName ? { fullName: context.actor.fullName } : void 0
@@ -8303,54 +8292,65 @@ function sameDestination(task, destination) {
 /** Look up a mutable task only after enforcing active-conversation ownership. */
 async function getWritableTask(args) {
 	const destination = requireActiveConversation(args.context);
-	const task = await readScheduledTask(getDb(), args.taskId);
-	if (!task || task.status === "deleted") throwToolInputError("Scheduled task was not found in the active Slack conversation.");
-	if (!sameDestination(task, destination)) throwToolInputError("Scheduled task can only be managed from the Slack destination where it currently delivers.");
+	const task = await readScheduledAutomation(getDb(), args.taskId);
+	if (!task || task.status === "deleted") throwToolInputError("Scheduled automation was not found in the active Slack conversation.");
+	if (!sameDestination(task, destination)) throwToolInputError("Scheduled automation can only be managed from the Slack destination where it currently delivers.");
 	return task;
 }
-/** Project scheduled task state into the stable model-facing result shape. */
-function compactTask(task) {
+/** Project scheduled automation state into the stable model-facing result shape. */
+function compactTask(task, requesterSlackUserId) {
 	return compactTaskResultSchema.parse({
 		id: task.id,
+		title: task.title?.trim() || null,
 		status: task.status,
-		task: task.task.text,
+		statusReason: task.statusReason ?? null,
+		createdAt: new Date(task.createdAtMs).toISOString(),
+		updatedAt: new Date(task.updatedAtMs).toISOString(),
+		originalRequest: task.originalRequest ?? null,
+		instruction: task.task.text,
 		schedule: task.schedule.description,
 		timezone: task.schedule.timezone,
 		recurrence: task.schedule.recurrence ? {
 			frequency: task.schedule.recurrence.frequency,
 			interval: task.schedule.recurrence.interval,
-			start_date: task.schedule.recurrence.startDate,
+			startDate: task.schedule.recurrence.startDate,
 			time: task.schedule.recurrence.time,
 			weekdays: task.schedule.recurrence.weekdays,
 			month: task.schedule.recurrence.month,
-			day_of_month: task.schedule.recurrence.dayOfMonth
+			dayOfMonth: task.schedule.recurrence.dayOfMonth
 		} : null,
-		next_run_at: task.nextRunAtMs ? new Date(task.nextRunAtMs).toISOString() : null,
+		nextRunAt: task.nextRunAtMs ? new Date(task.nextRunAtMs).toISOString() : null,
 		destination: {
-			platform: "slack",
-			team_id: task.destination.teamId,
-			channel_id: task.destination.channelId
+			channel: task.destination.channelId,
+			thread: task.destination.threadTs ?? null
 		},
-		conversation_access: task.conversationAccess,
-		credential_mode: task.credentialMode,
-		outcomes: effectiveTaskOutcomes(task.outcomes, task.destination),
-		dashboard_url: getDashboardTaskLink(task.id) ?? null,
-		last_run_at: task.lastRunAtMs ? new Date(task.lastRunAtMs).toISOString() : null,
-		run_now_at: task.runNowAtMs ? new Date(task.runNowAtMs).toISOString() : null
+		conversationAccess: task.conversationAccess,
+		credentialMode: task.credentialMode,
+		isCreator: task.createdBy.slackUserId === requesterSlackUserId,
+		createdBy: {
+			name: task.createdBy.fullName ?? null,
+			username: task.createdBy.userName ?? null
+		},
+		outcomes: effectiveTaskOutcomes(task.outcomes, task.destination).map((outcome) => ({
+			action: outcome.action,
+			destination: {
+				channel: outcome.destination.channelId,
+				thread: outcome.destination.threadTs ?? null
+			}
+		})),
+		dashboardUrl: getDashboardTaskLink(task.id) ?? null,
+		lastRunAt: task.lastRunAtMs ? new Date(task.lastRunAtMs).toISOString() : null,
+		runNowAt: task.runNowAtMs ? new Date(task.runNowAtMs).toISOString() : null
 	});
 }
 /** Build the structured result shared by single-task scheduler tools. */
-function scheduleTaskToolResult(target, task) {
-	return {
-		target,
-		task
-	};
+function scheduleAutomationToolResult(task, requesterSlackUserId) {
+	return { automation: compactTask(task, requesterSlackUserId) };
 }
 /** Build the structured result for listing scheduler tools. */
 function scheduleListToolResult(args) {
 	return {
-		target: args.target,
-		tasks: args.tasks,
+		automations: args.automations,
 		truncated: args.truncated
 	};
 }
@@ -8376,9 +8376,9 @@ function getDefaultScheduleTimezone() {
 	return process.env.JUNIOR_TIMEZONE?.trim() || DEFAULT_SCHEDULE_TIMEZONE;
 }
 //#endregion
-//#region src/chat/scheduled-tasks/tools/create.ts
-/** Create a tool that stores a scheduled task for the active Slack context. */
-function createSlackScheduleCreateTaskTool(context) {
+//#region src/chat/scheduled-automations/tools/create.ts
+/** Create a tool that stores a scheduled automation for the active Slack context. */
+function createSlackScheduleCreateAutomationTool(context) {
 	return zodTool({
 		approvalMode: "review",
 		annotations: {
@@ -8390,19 +8390,19 @@ function createSlackScheduleCreateTaskTool(context) {
 		description: "Create a one-time or recurring Junior task in the active Slack conversation when the user asks Junior to do work later or repeatedly.",
 		executionMode: "sequential",
 		inputSchema: z.object({
-			task: z.string().min(1).max(4e3),
+			instruction: z.string().min(1).max(4e3),
 			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(),
 			schedule: scheduleIntentSchema.describe("When the task runs. The scheduler computes the exact next run from this intent and the server clock."),
-			outcomes: z.array(taskOutcomeInputSchema).max(5).describe("Messages to send after successful work. Use an empty list to send nothing. Omit to send one message to the current Slack conversation.").optional(),
-			credential_mode: z.enum(["creator", "system"]).nullable().describe("Use creator to make the task creator's connected credentials available, or system when the creator says not to use them. Omit or use null for the creator default.").optional()
+			outcomes: z.array(taskOutcomeInputSchema).max(5).describe("Successful work is silent by default. Omit this field or use an empty list when the Automation should act through tools without a status message. Add send_message only when the user asks for a reminder, post, digest, summary, or other visible result.").optional(),
+			credentialMode: z.enum(["creator", "system"]).nullable().describe("Use creator to make the task creator's connected credentials available, or system when the creator says not to use them. Omit or use null for the creator default.").optional()
 		}).strict(),
 		prepareArguments(args) {
 			const prepared = { ...args };
 			if (prepared.title == null) delete prepared.title;
-			if (prepared.credential_mode === "creator" || prepared.credential_mode === null) delete prepared.credential_mode;
+			if (prepared.credentialMode === "creator" || prepared.credentialMode === null) delete prepared.credentialMode;
 			return prepared;
 		},
-		outputSchema: scheduleTaskToolResultSchema,
+		outputSchema: scheduleAutomationToolResultSchema,
 		execute: async (input, options) => {
 			const destination = requireActiveConversation(context);
 			const actor = requireActor(context, destination);
@@ -8412,13 +8412,13 @@ function createSlackScheduleCreateTaskTool(context) {
 				toolCallId: options.toolCallId
 			});
 			const db = getDb();
-			const existing = await readScheduledTask(db, id);
+			const existing = await readScheduledAutomation(db, id);
 			if (existing) {
-				if (!sameDestination(existing, destination) || existing.createdBy.slackUserId !== actor.slackUserId) throwToolInputError("Scheduled task operation identity is invalid.");
-				return scheduleTaskToolResult("slackScheduleCreateTask", compactTask(existing));
+				if (!sameDestination(existing, destination) || existing.createdBy.slackUserId !== actor.slackUserId) throwToolInputError("Scheduled automation operation identity is invalid.");
+				return scheduleAutomationToolResult(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 task creator identity is unavailable.");
+			if (!identity || identity.provider !== "slack" || identity.providerTenantId !== destination.teamId || identity.providerSubjectId !== actor.slackUserId) throwToolInputError("Scheduled automation creator identity is unavailable.");
 			const nowMs = context.now?.() ?? Date.now();
 			let compiled;
 			try {
@@ -8434,7 +8434,7 @@ function createSlackScheduleCreateTaskTool(context) {
 			const conversationAccess = getConversationAccess(destination, context.source);
 			const title = await resolveTaskTitle({
 				completeText,
-				instruction: input.task,
+				instruction: input.instruction,
 				title: input.title
 			});
 			const task = {
@@ -8444,28 +8444,28 @@ function createSlackScheduleCreateTaskTool(context) {
 				createdBy: actor,
 				creatorIdentityId: identity.id,
 				conversationAccess,
-				credentialMode: input.credential_mode ?? "creator",
+				credentialMode: input.credentialMode ?? "creator",
 				destination,
-				executionActor: SCHEDULED_TASK_SYSTEM_ACTOR,
+				executionActor: SCHEDULED_AUTOMATION_SYSTEM_ACTOR,
 				nextRunAtMs: compiled.nextRunAtMs,
 				originalRequest: context.userText,
 				schedule: compiled.schedule,
 				status: "active",
 				outcomes: await resolveTaskOutcomes(input.outcomes, destination, actor.slackUserId),
-				task: { text: input.task },
+				task: { text: input.instruction },
 				...title ? { title } : void 0
 			};
-			const committed = await createScheduledTask(db, task);
-			if (!sameDestination(committed, destination) || committed.createdBy.slackUserId !== actor.slackUserId) throwToolInputError("Scheduled task operation identity is invalid.");
-			logInfo("scheduled_task.create.completed", scheduledTaskAttributes(committed));
-			return scheduleTaskToolResult("slackScheduleCreateTask", compactTask(committed));
+			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);
 		}
 	});
 }
 //#endregion
-//#region src/chat/scheduled-tasks/tools/delete.ts
-/** Create a tool that removes a scheduled task from the active Slack conversation. */
-function createSlackScheduleDeleteTaskTool(context) {
+//#region src/chat/scheduled-automations/tools/delete.ts
+/** Create a tool that removes a scheduled automation from the active Slack conversation. */
+function createSlackScheduleDeleteAutomationTool(context) {
 	return zodTool({
 		approvalMode: "review",
 		annotations: {
@@ -8476,21 +8476,21 @@ function createSlackScheduleDeleteTaskTool(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({ task_id: z.string().min(1).describe("ID of the task to delete. Must be from this active Slack conversation.") }),
-		outputSchema: scheduleTaskToolResultSchema,
-		execute: async ({ task_id }) => {
+		inputSchema: z.object({ automationId: z.string().min(1).describe("ID of the task to delete. Must be from this active Slack conversation.") }),
+		outputSchema: scheduleAutomationToolResultSchema,
+		execute: async ({ automationId }) => {
 			const next = {
 				...await getWritableTask({
 					context,
-					taskId: task_id
+					taskId: automationId
 				}),
 				updatedAtMs: Date.now(),
 				status: "deleted",
 				nextRunAtMs: void 0,
 				runNowAtMs: void 0
 			};
-			await saveScheduledTask(getDb(), next);
-			return scheduleTaskToolResult("slackScheduleDeleteTask", compactTask(next));
+			await saveScheduledAutomation(getDb(), next);
+			return scheduleAutomationToolResult(next, context.actor?.userId);
 		}
 	});
 }
@@ -8529,7 +8529,7 @@ function parseRequiredSlackUserIdParam(field, value) {
 	};
 }
 //#endregion
-//#region src/chat/scheduled-tasks/tools/list.ts
+//#region src/chat/scheduled-automations/tools/list.ts
 function taskMatchesQuery(task, query) {
 	const normalized = query.toLowerCase();
 	return [
@@ -8540,10 +8540,10 @@ function taskMatchesQuery(task, query) {
 		task.status
 	].some((value) => value?.toLowerCase().includes(normalized));
 }
-/** Create a tool that lists scheduled tasks for the active conversation or the requester. */
-function createSlackScheduleListTasksTool(context) {
+/** Create a tool that lists scheduled automations for the active conversation or the requester. */
+function createSlackScheduleListAutomationsTool(context) {
 	return zodTool({
-		description: "List scheduled tasks in this Slack conversation. To find one of the requester's tasks elsewhere in the workspace, pass channel_id and/or query.",
+		description: "List scheduled automations in this Slack conversation. Each result says whether the requester is the creator. To find one of the requester's automations elsewhere in the workspace, pass channel_id and/or query.",
 		annotations: {
 			destructiveHint: false,
 			idempotentHint: true,
@@ -8552,7 +8552,7 @@ function createSlackScheduleListTasksTool(context) {
 		},
 		inputSchema: z.object({
 			channel_id: slackChannelIdParam("Current destination channel ID to filter by. Use the ID from a channel mention; do not guess.").nullable().optional(),
-			query: z.string().trim().min(1).max(200).nullable().describe("Text to match in the requester's scheduled tasks.").optional()
+			query: z.string().trim().min(1).max(200).nullable().describe("Text to match in the requester's scheduled automations.").optional()
 		}).strict(),
 		outputSchema: scheduleListToolResultSchema,
 		execute: async (input) => {
@@ -8566,7 +8566,7 @@ function createSlackScheduleListTasksTool(context) {
 			}
 			const query = input.query?.trim() || void 0;
 			const crossConversation = Boolean(query) || channelId !== void 0 && channelId !== destination.channelId;
-			const matching = (await listScheduledTasksForTeam(getDb(), destination.teamId)).filter((task) => {
+			const matching = (await listScheduledAutomationsForTeam(getDb(), destination.teamId)).filter((task) => {
 				if (task.destination.platform !== "slack") return false;
 				if (task.destination.teamId !== destination.teamId) return false;
 				if (task.status === "completed") return false;
@@ -8576,19 +8576,18 @@ function createSlackScheduleListTasksTool(context) {
 				if (query && !taskMatchesQuery(task, query)) return false;
 				return true;
 			}).sort((left, right) => right.createdAtMs - left.createdAtMs || right.id.localeCompare(left.id));
-			const visible = matching.slice(0, 50).map(compactTask);
+			const visible = matching.slice(0, 50).map((task) => compactTask(task, actor.slackUserId));
 			return scheduleListToolResult({
-				target: "slackScheduleListTasks",
-				tasks: visible,
+				automations: visible,
 				truncated: matching.length > visible.length
 			});
 		}
 	});
 }
 //#endregion
-//#region src/chat/scheduled-tasks/tools/run-now.ts
-/** Create a tool that marks an existing scheduled task due immediately. */
-function createSlackScheduleRunTaskNowTool(context) {
+//#region src/chat/scheduled-automations/tools/run-now.ts
+/** Create a tool that marks an existing scheduled automation due immediately. */
+function createSlackScheduleRunAutomationNowTool(context) {
 	return zodTool({
 		approvalMode: "review",
 		annotations: {
@@ -8597,31 +8596,31 @@ function createSlackScheduleRunTaskNowTool(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 task now. Use only task IDs returned for this conversation.",
+		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.",
 		executionMode: "sequential",
-		inputSchema: z.object({ task_id: z.string().min(1).describe("ID of the active task to run now. Must be from this active Slack conversation.") }),
-		outputSchema: scheduleTaskToolResultSchema,
-		execute: async ({ task_id }) => {
+		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,
+		execute: async ({ automationId }) => {
 			const lookup = await getWritableTask({
 				context,
-				taskId: task_id
+				taskId: automationId
 			});
-			if (lookup.status !== "active") throwToolInputError("Scheduled task must be active before it can be run now.");
+			if (lookup.status !== "active") throwToolInputError("Scheduled automation must be active before it can be run now.");
 			const nowMs = Date.now();
 			const next = {
 				...lookup,
 				updatedAtMs: nowMs,
 				runNowAtMs: nowMs
 			};
-			await saveScheduledTask(getDb(), next);
-			return scheduleTaskToolResult("slackScheduleRunTaskNow", compactTask(next));
+			await saveScheduledAutomation(getDb(), next);
+			return scheduleAutomationToolResult(next, context.actor?.userId);
 		}
 	});
 }
 //#endregion
-//#region src/chat/scheduled-tasks/tools/update.ts
-/** Create a tool that edits a scheduled task, including moving it here. */
-function createSlackScheduleUpdateTaskTool(context) {
+//#region src/chat/scheduled-automations/tools/update.ts
+/** Create a tool that edits a scheduled automation, including moving it here. */
+function createSlackScheduleUpdateAutomationTool(context) {
 	return zodTool({
 		approvalMode: "review",
 		annotations: {
@@ -8630,37 +8629,37 @@ function createSlackScheduleUpdateTaskTool(context) {
 			openWorldHint: true,
 			readOnlyHint: false
 		},
-		description: "Update a scheduled task. To move the requester's task into this Slack conversation, set destination to \"here\".",
+		description: "Update a scheduled automation. To move the requester's task into this Slack conversation, set destination to \"here\".",
 		executionMode: "sequential",
 		inputSchema: z.object({
-			task_id: z.string().min(1).describe("Scheduled task ID returned by slackScheduleListTasks."),
-			task: z.string().min(1).max(4e3).optional(),
+			automationId: z.string().min(1).describe("Scheduled automation ID returned by slackScheduleListAutomations."),
+			instruction: z.string().min(1).max(4e3).optional(),
 			schedule: scheduleIntentSchema.describe("Complete replacement schedule. Omit to keep it unchanged.").nullable().optional(),
 			outcomes: z.array(taskOutcomeInputSchema).max(5).describe("Replacement messages to send after successful work. Use an empty list to send nothing. Omit to keep unchanged.").optional(),
 			status: z.enum(["active", "blocked"]).describe("Set active to resume a blocked task, or blocked to stop dispatch.").optional(),
 			destination: z.literal("here").nullable().describe("Set to \"here\" to move the creator's task into this Slack conversation. Omit to keep its destination.").optional(),
-			credential_mode: z.enum(["system", "creator"]).nullable().describe("Use creator credentials or system credentials. Only the task creator may enable creator mode. Omit to keep unchanged.").optional()
+			credentialMode: z.enum(["system", "creator"]).nullable().describe("Use creator credentials or system credentials. Only the task creator may enable creator mode. Omit to keep unchanged.").optional()
 		}).strict(),
-		outputSchema: scheduleTaskToolResultSchema,
+		outputSchema: scheduleAutomationToolResultSchema,
 		execute: async (input) => {
 			const activeDestination = requireActiveConversation(context);
 			const actor = requireActor(context, activeDestination);
 			const db = getDb();
-			const lookup = await readScheduledTask(db, input.task_id);
-			if (!lookup || lookup.status === "deleted") throwToolInputError("Scheduled task was not found.");
-			if (lookup.status === "completed") throwToolInputError("Completed scheduled tasks cannot be updated. Create a new task instead.");
-			if (lookup.destination.platform !== "slack") throwToolInputError("Scheduled task destination is invalid.");
-			if (lookup.destination.teamId !== activeDestination.teamId) throwToolInputError("Scheduled tasks can only be managed within the same Slack workspace.");
+			const lookup = await readScheduledAutomation(db, input.automationId);
+			if (!lookup || lookup.status === "deleted") throwToolInputError("Scheduled automation was not found.");
+			if (lookup.status === "completed") throwToolInputError("Completed scheduled automations cannot be updated. Create a new automation instead.");
+			if (lookup.destination.platform !== "slack") throwToolInputError("Scheduled automation destination is invalid.");
+			if (lookup.destination.teamId !== activeDestination.teamId) throwToolInputError("Scheduled automations can only be managed within the same Slack workspace.");
 			const moveHere = input.destination === "here";
 			const alreadyHere = sameDestination(lookup, activeDestination);
 			const isCreator = actor.slackUserId === lookup.createdBy.slackUserId;
-			if (!alreadyHere && !moveHere) throwToolInputError("Scheduled task can only be managed from the Slack destination where it currently delivers. Set destination to \"here\" to move it into this conversation.");
-			if (moveHere && !isCreator) throwToolInputError("Only the scheduled task creator can move this task.");
-			if (input.credential_mode === "creator" && !isCreator) throwToolInputError("Only the scheduled task creator can enable creator credential use.");
-			if (input.outcomes !== void 0 && !isCreator) throwToolInputError("Only the scheduled task creator can change message destinations.");
+			if (!alreadyHere && !moveHere) throwToolInputError("Scheduled automation can only be managed from the Slack destination where it currently delivers. Set destination to \"here\" to move it into this conversation.");
+			if (moveHere && !isCreator) throwToolInputError("Only the scheduled automation creator can move this task.");
+			if (input.credentialMode === "creator" && !isCreator) throwToolInputError("Only the scheduled automation creator can enable creator credential use.");
+			if (input.outcomes !== void 0 && !isCreator) throwToolInputError("Only the scheduled automation creator can change message destinations.");
 			const changingDestination = moveHere && !alreadyHere;
 			if (changingDestination) {
-				if ((await db.select({ id: juniorSchedulerRuns.id }).from(juniorSchedulerRuns).where(and(eq(juniorSchedulerRuns.taskId, lookup.id), inArray(juniorSchedulerRuns.status, ["pending", "running"]))).limit(1)).length > 0) throwToolInputError("Scheduled task cannot be moved while an occurrence is already running. Try again after the current run finishes.");
+				if ((await db.select({ id: juniorSchedulerRuns.id }).from(juniorSchedulerRuns).where(and(eq(juniorSchedulerRuns.taskId, lookup.id), inArray(juniorSchedulerRuns.status, ["pending", "running"]))).limit(1)).length > 0) throwToolInputError("Scheduled automation cannot be moved while an occurrence is already running. Try again after the current run finishes.");
 			}
 			const nowMs = context.now?.() ?? Date.now();
 			let compiled;
@@ -8677,10 +8676,10 @@ function createSlackScheduleUpdateTaskTool(context) {
 			const nextRunAtMs = compiled?.nextRunAtMs ?? lookup.nextRunAtMs;
 			const status = normalizeStatus(input.status);
 			if (input.status && !status) throwToolInputError("status must be active or blocked.");
-			if (status === "active" && !nextRunAtMs) throwToolInputError("Active scheduled tasks require a schedule with a future occurrence.");
+			if (status === "active" && !nextRunAtMs) throwToolInputError("Active scheduled automations require a schedule with a future occurrence.");
 			const nextStatus = status ?? lookup.status;
-			const credentialMode = input.task !== void 0 && input.task !== lookup.task.text && !isCreator ? "system" : input.credential_mode ?? lookup.credentialMode;
-			const nextInstruction = input.task !== void 0 ? input.task : lookup.task.text;
+			const credentialMode = input.instruction !== void 0 && input.instruction !== lookup.task.text && !isCreator ? "system" : input.credentialMode ?? lookup.credentialMode;
+			const nextInstruction = input.instruction !== void 0 ? input.instruction : lookup.task.text;
 			const instructionChanged = nextInstruction !== lookup.task.text;
 			const nextDestination = changingDestination ? activeDestination : lookup.destination;
 			const next = {
@@ -8706,16 +8705,16 @@ function createSlackScheduleUpdateTaskTool(context) {
 				if (title) next.title = title;
 				else delete next.title;
 			}
-			if (!changingDestination && !instructionChanged && !compiled && status === void 0 && (input.credential_mode === void 0 || input.credential_mode === null || input.credential_mode === lookup.credentialMode) && input.outcomes === void 0 && moveHere) return scheduleTaskToolResult("slackScheduleUpdateTask", compactTask(lookup));
-			const committed = await saveScheduledTask(db, next);
-			if (changingDestination) logInfo("scheduled_task.move.completed", scheduledTaskAttributes(committed));
-			return scheduleTaskToolResult("slackScheduleUpdateTask", compactTask(committed));
+			if (!changingDestination && !instructionChanged && !compiled && status === void 0 && (input.credentialMode === void 0 || input.credentialMode === null || input.credentialMode === lookup.credentialMode) && input.outcomes === void 0 && moveHere) return scheduleAutomationToolResult(lookup, actor.slackUserId);
+			const committed = await saveScheduledAutomation(db, next);
+			if (changingDestination) logInfo("scheduled_automation.move.completed", scheduledAutomationAttributes(committed));
+			return scheduleAutomationToolResult(committed, actor.slackUserId);
 		}
 	});
 }
 //#endregion
-//#region src/chat/tools/scheduled-tasks.ts
-function scheduledTaskToolContext(context) {
+//#region src/chat/tools/scheduled-automations.ts
+function scheduledAutomationToolContext(context) {
 	if (context.source.kind !== "slack" || context.destination.platform !== "slack" || context.actor?.platform !== "slack" || !context.resolveActorIdentity) return;
 	return {
 		actor: context.actor,
@@ -8724,16 +8723,16 @@ function scheduledTaskToolContext(context) {
 		...context.userText ? { userText: context.userText } : void 0
 	};
 }
-/** Build scheduled-task tools for an interactive Slack actor. */
-function createScheduledTaskTools(context) {
-	const taskContext = scheduledTaskToolContext(context);
+/** Build scheduled-automation tools for an interactive Slack actor. */
+function createScheduledAutomationTools(context) {
+	const taskContext = scheduledAutomationToolContext(context);
 	if (!taskContext) return {};
 	return {
-		slackScheduleCreateTask: createSlackScheduleCreateTaskTool(taskContext),
-		slackScheduleListTasks: createSlackScheduleListTasksTool(taskContext),
-		slackScheduleUpdateTask: createSlackScheduleUpdateTaskTool(taskContext),
-		slackScheduleDeleteTask: createSlackScheduleDeleteTaskTool(taskContext),
-		slackScheduleRunTaskNow: createSlackScheduleRunTaskNowTool(taskContext)
+		slackScheduleCreateAutomation: createSlackScheduleCreateAutomationTool(taskContext),
+		slackScheduleListAutomations: createSlackScheduleListAutomationsTool(taskContext),
+		slackScheduleUpdateAutomation: createSlackScheduleUpdateAutomationTool(taskContext),
+		slackScheduleDeleteAutomation: createSlackScheduleDeleteAutomationTool(taskContext),
+		slackScheduleRunAutomationNow: createSlackScheduleRunAutomationNowTool(taskContext)
 	};
 }
 //#endregion
@@ -9147,6 +9146,34 @@ function createSlackChannelListMessagesTool(context) {
 	});
 }
 //#endregion
+//#region src/chat/slack/tools/conversation-brief-search.ts
+/** Create Slack-owned filtering and match details for Brief search. */
+function createSlackConversationBriefSearchPort(teamId) {
+	return {
+		channelFilterSchema: slackChannelRefParam,
+		async resolveChannel(input) {
+			return (await resolveSlackChannelRef({
+				field: "channel_id",
+				value: input,
+				teamId
+			})).channelId;
+		},
+		async describeMatch(match) {
+			const reference = parseSlackThreadId(match.conversationId);
+			if (!reference || reference.channelId !== match.providerDestinationId) return {};
+			const permalink = await getSlackMessagePermalink({
+				channelId: reference.channelId,
+				messageTs: reference.threadTs
+			});
+			return {
+				channel_id: reference.channelId,
+				...match.channelName ? { channel_name: match.channelName } : void 0,
+				...permalink ? { permalink } : void 0
+			};
+		}
+	};
+}
+//#endregion
 //#region src/chat/conversations/tool-source.ts
 /** Deferred tool catalog source for retained Junior conversations. */
 const CONVERSATIONS_TOOL_SOURCE = {
@@ -9155,8 +9182,8 @@ const CONVERSATIONS_TOOL_SOURCE = {
 };
 //#endregion
 //#region src/chat/slack/tools/conversation-message-search.ts
-const DEFAULT_LIMIT$2 = 20;
-const MAX_LIMIT$1 = 50;
+const DEFAULT_LIMIT$3 = 20;
+const MAX_LIMIT$2 = 50;
 const conversationMessageSearchOutputSchema = juniorToolOutputSchema.extend({
 	after: z.string().datetime().optional(),
 	annotation: z.string().min(1).optional(),
@@ -9176,17 +9203,17 @@ const conversationMessageSearchOutputSchema = juniorToolOutputSchema.extend({
 		thread_ts: z.string().min(1)
 	}).strict())
 });
-function parseTimestamp(field, value) {
+function parseTimestamp$1(field, value) {
 	if (value == null || value.trim() === "") return;
 	const parsed = Date.parse(value);
 	if (!Number.isFinite(parsed)) throw new ToolInputError(`${field} must be a valid ISO-8601 timestamp`);
 	return parsed;
 }
-async function resolveSearchFilters(input) {
+async function resolveSearchFilters$1(input) {
 	const query = input.query?.trim() || void 0;
 	const annotation = input.annotation?.trim() || void 0;
-	const afterMs = parseTimestamp("after", input.after);
-	const beforeMs = parseTimestamp("before", input.before);
+	const afterMs = parseTimestamp$1("after", input.after);
+	const beforeMs = parseTimestamp$1("before", input.before);
 	let channelId;
 	if (input.channel_id != null && input.channel_id.trim() !== "") channelId = (await resolveSlackChannelRef({
 		field: "channel_id",
@@ -9221,20 +9248,20 @@ function createSlackConversationMessageSearchTool(scope, currentConversationId)
 			before: z.string().datetime().nullable().describe("Include conversations active before this timestamp.").optional(),
 			channel_id: slackChannelRefParam.nullable().optional(),
 			query: z.string().trim().min(1).max(200).nullable().describe("Words or phrase to match in message text.").optional(),
-			limit: z.number().int().min(1).max(MAX_LIMIT$1).describe(`Maximum conversations. Default ${DEFAULT_LIMIT$2}; max ${MAX_LIMIT$1}.`).nullable().optional()
+			limit: z.number().int().min(1).max(MAX_LIMIT$2).describe(`Maximum conversations. Default ${DEFAULT_LIMIT$3}; max ${MAX_LIMIT$2}.`).nullable().optional()
 		}).strict(),
 		outputSchema: conversationMessageSearchOutputSchema,
 		execute: async (input) => {
 			const teamId = parseSlackTeamId(scope.providerTenantId);
 			if (!teamId) throw new ToolInputError("Cannot search retained messages without a valid Slack workspace id.");
-			const filters = await resolveSearchFilters({
+			const filters = await resolveSearchFilters$1({
 				...input,
 				teamId
 			});
 			const matches = await getConversationMessageSearchStore().search({
 				currentConversationId,
 				filters,
-				limit: input.limit ?? DEFAULT_LIMIT$2,
+				limit: input.limit ?? DEFAULT_LIMIT$3,
 				scope
 			});
 			const matchesOutput = await Promise.all(matches.map(async (match) => {
@@ -9270,7 +9297,7 @@ function createSlackConversationMessageSearchTool(scope, currentConversationId)
 }
 //#endregion
 //#region src/chat/slack/tools/public-search.ts
-const DEFAULT_LIMIT$1 = 10;
+const DEFAULT_LIMIT$2 = 10;
 const DEFAULT_CONTENT_TYPES = ["messages"];
 const CONTENT_TYPES = [
 	"messages",
@@ -9533,7 +9560,7 @@ function createSlackPublicSearchTool(actionToken) {
 					channel_types: ["public_channel"],
 					content_types: normalizedContentTypes,
 					include_bots: true,
-					limit: limit ?? DEFAULT_LIMIT$1,
+					limit: limit ?? DEFAULT_LIMIT$2,
 					...normalizedAfter !== void 0 ? { after: normalizedAfter } : void 0,
 					...normalizedBefore !== void 0 ? { before: normalizedBefore } : void 0,
 					...cursor ? { cursor } : void 0,
@@ -11709,8 +11736,8 @@ function createLoadAttachmentTool(args) {
 }
 //#endregion
 //#region src/chat/tools/search-conversation-events.ts
-const DEFAULT_LIMIT = 25;
-const MAX_LIMIT = 100;
+const DEFAULT_LIMIT$1 = 25;
+const MAX_LIMIT$1 = 100;
 const MAX_EVENT_DATA_BYTES = 4e3;
 const MAX_EVENTS_JSON_BYTES = 2e4;
 const MAX_IDENTITY_CHARS = 256;
@@ -11746,7 +11773,7 @@ function createSearchConversationEventsTool(context) {
 			conversation_id: z.string().trim().min(1).nullable().describe("Conversation ID to search. Omit or null for the current conversation.").optional(),
 			after_seq: z.number().int().nonnegative().nullable().describe("Exclusive event sequence lower bound; returns ascending.").optional(),
 			before_seq: z.number().int().nonnegative().nullable().describe("Exclusive event sequence upper bound.").optional(),
-			limit: z.number().int().min(1).max(MAX_LIMIT).nullable().describe(`Maximum events. Default ${DEFAULT_LIMIT}; max ${MAX_LIMIT}.`).optional(),
+			limit: z.number().int().min(1).max(MAX_LIMIT$1).nullable().describe(`Maximum events. Default ${DEFAULT_LIMIT$1}; max ${MAX_LIMIT$1}.`).optional(),
 			types: z.array(knownEventTypeSchema).min(1).nullable().describe("Event types to include; omit for all types.").optional()
 		}).strict(),
 		outputSchema: searchConversationEventsOutputSchema,
@@ -11755,7 +11782,7 @@ function createSearchConversationEventsTool(context) {
 			const conversationId = input.conversation_id?.trim() || currentConversationId;
 			const afterSeq = input.after_seq ?? void 0;
 			const beforeSeq = input.before_seq ?? void 0;
-			const limit = input.limit ?? DEFAULT_LIMIT;
+			const limit = input.limit ?? DEFAULT_LIMIT$1;
 			const types = input.types ?? void 0;
 			if (afterSeq !== void 0 && beforeSeq !== void 0 && afterSeq >= beforeSeq) throw new ToolInputError("after_seq must be less than before_seq when both are provided");
 			const conversationStore = getConversationStore();
@@ -11919,6 +11946,183 @@ function stripReplacementHistoryField(value) {
 	};
 }
 //#endregion
+//#region src/chat/briefs/search.ts
+/** Search the latest Brief of each public root Conversation in one scope. */
+async function searchConversationBriefs(db, args) {
+	const query = args.filters.query?.trim() || void 0;
+	const tsquery = query ? sql`websearch_to_tsquery('english', ${query})` : void 0;
+	const briefs = juniorConversationBriefs;
+	const newer = alias(juniorConversationBriefs, "newer_briefs");
+	const searchVector = sql`to_tsvector('english', ${briefs.searchText})`;
+	const rank = tsquery ? sql`ts_rank_cd(${searchVector}, ${tsquery})` : sql`1`;
+	const excerpt = tsquery ? sql`ts_headline('english', ${briefs.searchText}, ${tsquery}, 'MaxFragments=2, MinWords=8, MaxWords=40, FragmentDelimiter=" … ", StartSel=**, StopSel=**')` : sql`${briefs.content}->>'summary'`;
+	const outcomeStatus = sql`${briefs.content}->'outcome'->>'status'`;
+	const conditions = [
+		notExists(db.select({ one: sql`1` }).from(newer).where(and(eq(newer.conversationId, briefs.conversationId), gt(newer.version, briefs.version)))),
+		isNull(juniorConversations.parentConversationId),
+		ne(juniorConversations.conversationId, args.currentConversationId),
+		eq(juniorDestinations.visibility, "public")
+	];
+	if (args.scope.kind === "public_provider_tenant") conditions.push(eq(juniorConversations.source, args.scope.provider), eq(juniorDestinations.provider, args.scope.provider), eq(juniorDestinations.providerTenantId, args.scope.providerTenantId));
+	if (tsquery) conditions.push(sql`${searchVector} @@ ${tsquery}`);
+	if (args.filters.channelId) conditions.push(eq(juniorDestinations.providerDestinationId, args.filters.channelId));
+	if (args.filters.status) conditions.push(sql`${outcomeStatus} = ${args.filters.status}`);
+	if (args.filters.afterMs !== void 0) conditions.push(gte(briefs.createdAt, new Date(args.filters.afterMs)));
+	if (args.filters.beforeMs !== void 0) conditions.push(lt(briefs.createdAt, new Date(args.filters.beforeMs)));
+	if (args.filters.annotation) {
+		const annotation = args.filters.annotation.toLowerCase();
+		const nestedAnnotationPrefix = `${annotation}#`;
+		conditions.push(sql`exists (
+        select 1
+        from ${juniorConversationAnnotations}
+        where ${and(eq(juniorConversationAnnotations.conversationId, juniorConversations.conversationId), sql`(
+            lower(${juniorConversationAnnotations.key}) = ${annotation}
+            or starts_with(
+              lower(${juniorConversationAnnotations.key}),
+              ${nestedAnnotationPrefix}
+            )
+          )`)}
+      )`);
+	}
+	return (await db.select({
+		channelName: juniorDestinations.displayName,
+		content: briefs.content,
+		conversationId: juniorConversations.conversationId,
+		excerpt: excerpt.as("excerpt"),
+		providerDestinationId: juniorDestinations.providerDestinationId,
+		rank: rank.as("rank"),
+		title: juniorConversations.title,
+		updatedAt: briefs.createdAt,
+		version: briefs.version
+	}).from(briefs).innerJoin(juniorConversations, eq(juniorConversations.conversationId, briefs.conversationId)).innerJoin(juniorDestinations, eq(juniorDestinations.id, juniorConversations.destinationId)).where(and(...conditions)).orderBy(desc(rank), desc(briefs.createdAt)).limit(args.limit)).map((row) => {
+		const content = conversationBriefSchema.parse(row.content);
+		return {
+			conversationId: row.conversationId,
+			excerpt: row.excerpt,
+			links: content.links.slice(0, 5),
+			outcomeStatus: content.outcome.status,
+			providerDestinationId: row.providerDestinationId,
+			summary: content.summary,
+			updatedAtMs: row.updatedAt.getTime(),
+			version: row.version,
+			...row.channelName ? { channelName: row.channelName } : void 0,
+			...row.title ? { title: row.title } : void 0
+		};
+	});
+}
+//#endregion
+//#region src/chat/tools/search-conversation-briefs.ts
+const DEFAULT_LIMIT = 10;
+const MAX_LIMIT = 25;
+const conversationBriefSearchOutputSchema = juniorToolOutputSchema.extend({
+	after: z.string().datetime().optional(),
+	annotation: z.string().min(1).optional(),
+	before: z.string().datetime().optional(),
+	channel_id: z.string().min(1).optional(),
+	count: z.number().int().nonnegative(),
+	matches: z.array(z.object({
+		channel_id: z.string().min(1).optional(),
+		channel_name: z.string().min(1).optional(),
+		conversation_id: z.string().min(1),
+		dashboard_url: z.string().url().optional(),
+		excerpt: z.string(),
+		links: z.array(briefLinkSchema).max(5),
+		permalink: z.string().url().optional(),
+		status: briefOutcomeStatusSchema,
+		summary: z.string().min(1),
+		title: z.string().min(1).optional(),
+		updated_at: z.string().datetime(),
+		version: z.number().int().positive()
+	}).strict()),
+	query: z.string().optional(),
+	status: briefOutcomeStatusSchema.optional()
+});
+function parseTimestamp(field, value) {
+	if (value == null || value.trim() === "") return void 0;
+	const parsed = Date.parse(value);
+	if (!Number.isFinite(parsed)) throw new ToolInputError(`${field} must be a valid ISO-8601 timestamp`);
+	return parsed;
+}
+async function resolveSearchFilters(input, provider) {
+	const query = input.query?.trim() || void 0;
+	const annotation = input.annotation?.trim() || void 0;
+	const afterMs = parseTimestamp("after", input.after);
+	const beforeMs = parseTimestamp("before", input.before);
+	let channelId;
+	if (typeof input.channel_id === "string" && input.channel_id.trim() !== "") {
+		if (!provider) throw new ToolInputError("channel_id is not available in this conversation.");
+		channelId = await provider.resolveChannel(input.channel_id);
+	}
+	if (afterMs !== void 0 && beforeMs !== void 0 && afterMs >= beforeMs) throw new ToolInputError("`after` must be earlier than `before`");
+	return {
+		...afterMs !== void 0 ? { afterMs } : void 0,
+		...annotation ? { annotation } : void 0,
+		...beforeMs !== void 0 ? { beforeMs } : void 0,
+		...channelId ? { channelId } : void 0,
+		...query ? { query } : void 0,
+		...input.status ? { status: input.status } : void 0
+	};
+}
+/** Create a deferred tool that searches the latest public Conversation Briefs. */
+function createSearchConversationBriefsTool(scope, currentConversationId, provider) {
+	return zodTool({
+		description: "Search Briefs from past public conversations. Briefs preserve intent, outcomes, decisions, facts, and links after transcripts expire. Use this before searchConversationMessages for questions such as what was decided or which pull request handled the work.",
+		exposure: "deferred",
+		source: CONVERSATIONS_TOOL_SOURCE,
+		annotations: {
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false,
+			readOnlyHint: true
+		},
+		inputSchema: z.object({
+			after: z.string().datetime().nullable().describe("Include Briefs updated at or after this timestamp.").optional(),
+			annotation: z.string().trim().min(1).max(256).nullable().describe("Linked resource key. Matches that key, or nested children that continue with #.").optional(),
+			before: z.string().datetime().nullable().describe("Include Briefs updated before this timestamp.").optional(),
+			...provider ? { channel_id: provider.channelFilterSchema.nullable().optional() } : void 0,
+			limit: z.number().int().min(1).max(MAX_LIMIT).nullable().describe(`Maximum conversations. Default ${DEFAULT_LIMIT}; max ${MAX_LIMIT}.`).optional(),
+			query: z.string().trim().min(1).max(200).nullable().describe("Words or phrase to match in current Briefs.").optional(),
+			status: briefOutcomeStatusSchema.nullable().describe("Current Brief outcome status.").optional()
+		}).strict(),
+		outputSchema: conversationBriefSearchOutputSchema,
+		execute: async (input) => {
+			const filters = await resolveSearchFilters(input, provider);
+			const matches = await searchConversationBriefs(getDb(), {
+				currentConversationId,
+				filters,
+				limit: input.limit ?? DEFAULT_LIMIT,
+				scope
+			});
+			const outputMatches = await Promise.all(matches.map(async (match) => {
+				const providerFields = provider ? await provider.describeMatch(match) : void 0;
+				const dashboardUrl = getDashboardConversationLink(match.conversationId);
+				return {
+					conversation_id: match.conversationId,
+					status: match.outcomeStatus,
+					updated_at: new Date(match.updatedAtMs).toISOString(),
+					version: match.version,
+					summary: match.summary,
+					excerpt: match.excerpt,
+					links: match.links,
+					...match.title ? { title: match.title } : void 0,
+					...dashboardUrl ? { dashboard_url: dashboardUrl } : void 0,
+					...providerFields
+				};
+			}));
+			return {
+				...filters.afterMs !== void 0 ? { after: new Date(filters.afterMs).toISOString() } : void 0,
+				...filters.annotation ? { annotation: filters.annotation } : void 0,
+				...filters.beforeMs !== void 0 ? { before: new Date(filters.beforeMs).toISOString() } : void 0,
+				...filters.channelId ? { channel_id: filters.channelId } : void 0,
+				...filters.query ? { query: filters.query } : void 0,
+				...filters.status ? { status: filters.status } : void 0,
+				count: outputMatches.length,
+				matches: outputMatches
+			};
+		}
+	});
+}
+//#endregion
 //#region src/chat/tools/handoff/tool.ts
 const HANDOFF_TOOL_NAME = "handoff";
 function formatHandoffProfiles(handoff) {
@@ -12595,7 +12799,7 @@ async function tryRecordWorkspaceSwitchStat(workspace) {
 }
 async function stopWorkspaceSnapshotWatch(input) {
 	try {
-		await cancelResourceEventSubscription({
+		await cancelWatch({
 			conversationId: input.conversationId,
 			id: input.subscriptionId
 		});
@@ -12792,7 +12996,7 @@ function createWorkspaceTools(context) {
 			outputSchema: juniorToolOutputSchema.extend({
 				workspace: workspaceSchema,
 				status: z.enum(["ready", "building"]),
-				subscription: resourceEventSubscriptionResultSchema.optional().describe("Present when the snapshot ready and failed events are already watched for this conversation.")
+				subscription: watchResultSchema.optional().describe("Present when the snapshot ready and failed events are already watched for this conversation.")
 			}),
 			async execute({ name }, options) {
 				const workspace = await getWorkspaceByName(getDb(), name);
@@ -12802,7 +13006,7 @@ function createWorkspaceTools(context) {
 					workspaceName: workspace.name
 				});
 				const conversationId = context.conversationId.trim();
-				const subscription = conversationId ? await createResourceEventSubscription({
+				const subscription = conversationId ? await createWatch({
 					conversationId,
 					events: [WORKSPACE_SNAPSHOT_READY_EVENT, WORKSPACE_SNAPSHOT_FAILED_EVENT],
 					expiresAtMs: Date.now() + RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS,
@@ -12867,7 +13071,7 @@ function createTools(availableSkills, hooks = {}, context, options = {}) {
 	const slackContext = getSlackToolContext(context);
 	const slackLocationCapabilities = slackContext ? resolveChannelCapabilities(slackContext.locationChannelId) : void 0;
 	const canSendFilesToActiveConversation = Boolean(slackContext && slackLocationCapabilities?.canSendFiles);
-	const resourceEventCatalog = getResourceEventCatalog();
+	const eventCatalog = getEventCatalog();
 	const tools = {
 		...options.includeLoadSkill === false ? void 0 : { loadSkill: createLoadSkillTool(availableSkills, { onSkillLoaded: hooks.onSkillLoaded }) },
 		reportProgress: createReportProgressTool(),
@@ -12881,12 +13085,17 @@ function createTools(availableSkills, hooks = {}, context, options = {}) {
 		writeFile: createWriteFileTool(),
 		webSearch: createWebSearchTool(botConfig.webSearchModelId, hooks.toolOverrides?.webSearch),
 		webFetch: createWebFetchTool(hooks, { canSendFilesToActiveConversation }),
-		...createResourceEventTools(context, resourceEventCatalog),
-		...createEventTaskTools(context, resourceEventCatalog),
-		...createScheduledTaskTools(context),
+		...createEventTools(context, eventCatalog),
+		...createEventAutomationTools(context, eventCatalog),
+		...createScheduledAutomationTools(context),
 		...createWorkspaceTools(context)
 	};
 	tools.searchConversationEvents = createSearchConversationEventsTool(context);
+	if (context.conversationPrivacy === "public") tools.searchConversationBriefs = createSearchConversationBriefsTool(slackContext ? {
+		kind: "public_provider_tenant",
+		provider: "slack",
+		providerTenantId: slackContext.teamId
+	} : { kind: "public" }, context.conversationId, slackContext ? createSlackConversationBriefSearchPort(slackContext.teamId) : void 0);
 	if (context.supportsImageInput) tools.viewImage = createViewImageTool(context.workspace, context.supportsImageInput, hooks.toolOverrides?.viewImage);
 	if (hooks.writeGeneratedArtifacts) tools.imageGenerate = createImageGenerateTool({ writeGeneratedArtifacts: hooks.writeGeneratedArtifacts }, {
 		modelId: botConfig.imageGenerationModelId,
@@ -15254,7 +15463,7 @@ Assess the exact action's intrinsic risk and whether the user's intent authorize
 ## Data Exfiltration
 - Sending private data, organization data, secrets, or credentials to an untrusted destination is high or critical risk.
 - A user-requested read, query, or upload to a trusted destination is not exfiltration by default.
-- The active Junior conversation is not an untrusted destination merely because it is a public or multi-user channel. For a scheduled task or event task, 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.
+- The active Junior conversation is not an untrusted destination merely because it is a public or multi-user channel. 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.
 - Using an existing credential to authenticate a user-requested action is not credential exfiltration by itself.
 - Ordinary product context such as internal system names, repository names, or workflow descriptions is not private organization data by itself, including on an authorized public write destination.
 - Deny disclosure of secrets, credentials, or private organization data to an untrusted destination even when the user requested it.
@@ -15548,9 +15757,9 @@ function resolveToolRuntimeRoute(args) {
 			actor: args.actor?.platform === "web" ? args.actor : void 0,
 			source: args.run.source
 		};
-		case "resource_event":
-		case "scheduled_task":
-		case "event_task":
+		case "event":
+		case "scheduled_automation":
+		case "event_automation":
 		case "plugin_dispatch":
 		case "agent_invocation": return {
 			destination,
@@ -17518,4 +17727,4 @@ async function executeAgentRunInPrivacyContext(run, conversationPrivacy, runLogC
 	}
 }
 //#endregion
-export { buildSteeringPiMessage as $, createAgentInvocationSchema as A, renderTaskInput as B, renderBlockText as C, getNextRunAtMs as D, scheduledTaskRunAttributes as E, ingestResourceEvent as F, shouldPropagateSandboxEgressTrace as G, recordFinishedTurnForAutomatedLimit as H, isResourceEventMailboxMetadata as I, consumeSandboxEgressAuthRequiredSignal as J, SANDBOX_EGRESS_PROXY_PATH as K, RESOURCE_EVENT_MESSAGE_AUTHOR as L, AgentInvocationLimitError as M, getMcpProviderErrorAttributes as N, agentBindingSchema as O, processWorkspaceSnapshotJob as P, createUserTokenStore as Q, RESOURCE_EVENT_SYSTEM_ACTOR as R, renderAttachmentText as S, logScheduledTaskRunSkipped as T, resolveSandboxEgressProviderForHost as U, maybePostAutomatedTurnLimitNotice as V, normalizeSandboxEgressTracePropagationDomains as W, parseSandboxEgressCredentialToken as X, consumeSandboxEgressPermissionDeniedSignal as Y, sandboxEgressSignalsResponseSchema as Z, readPublicArtifact as _, deleteMcpAuthSession as a, readAttachmentVisionSummary as b, deleteMcpStoredOAuthCredentials as c, putMcpStoredOAuthCredentials as d, isVisionImageMediaType as et, PluginCredentialFailureError as f, publicArtifactHeaders as g, resolvePluginOAuthAccount as h, finalizeMcpAuthorization as i, setConfigDefaults as it, AgentInvocationBusyError as j, agentInvocationSchema as k, getMcpAuthSession as l, latestReportedProgress as m, createContextCompactor as n, shouldEmitDevAgentTrace as nt, deleteMcpAuthSessionsForUserProvider as o, authorizationId as p, clearSandboxEgressSignals as q, executeCredentialedEgressRequest as r, getConfigDefaults as rt, deleteMcpServerSessionId as s, executeAgentRun as t, AuthorizationFlowDisabledError as tt, getMcpStoredOAuthCredentials as u, unpublishedArtifactHeaders as v, listThreadReplies as w, recordSlackAttachment as x, lookupSlackUserProfile as y, isResourceEventConversationMessage as z };
+export { shouldEmitDevAgentTrace as $, createAgentInvocationSchema as A, resolveSandboxEgressProviderForHost as B, renderBlockText as C, getNextRunAtMs as D, scheduledAutomationRunAttributes as E, ingestEvent as F, consumeSandboxEgressAuthRequiredSignal as G, shouldPropagateSandboxEgressTrace as H, isEventMailboxMetadata as I, sandboxEgressSignalsResponseSchema as J, consumeSandboxEgressPermissionDeniedSignal as K, renderTaskInput as L, AgentInvocationLimitError as M, getMcpProviderErrorAttributes as N, agentBindingSchema as O, processWorkspaceSnapshotJob as P, AuthorizationFlowDisabledError as Q, maybePostAutomatedTurnLimitNotice as R, renderAttachmentText as S, logScheduledAutomationRunSkipped as T, SANDBOX_EGRESS_PROXY_PATH as U, normalizeSandboxEgressTracePropagationDomains as V, clearSandboxEgressSignals as W, buildSteeringPiMessage as X, createUserTokenStore as Y, isVisionImageMediaType as Z, readPublicArtifact as _, deleteMcpAuthSession as a, readAttachmentVisionSummary as b, deleteMcpStoredOAuthCredentials as c, putMcpStoredOAuthCredentials as d, getConfigDefaults as et, PluginCredentialFailureError as f, publicArtifactHeaders as g, resolvePluginOAuthAccount as h, finalizeMcpAuthorization as i, AgentInvocationBusyError as j, agentInvocationSchema as k, getMcpAuthSession as l, latestReportedProgress as m, createContextCompactor as n, deleteMcpAuthSessionsForUserProvider as o, authorizationId as p, parseSandboxEgressCredentialToken as q, executeCredentialedEgressRequest as r, deleteMcpServerSessionId as s, executeAgentRun as t, setConfigDefaults as tt, getMcpStoredOAuthCredentials as u, unpublishedArtifactHeaders as v, listThreadReplies as w, recordSlackAttachment as x, lookupSlackUserProfile as y, recordFinishedTurnForAutomatedLimit as z };