@sentry/junior 0.185.0 → 0.186.0

package/dist/{catalog-runtime-AAEAO2RL.js → catalog-runtime-AFJCAOHC.js}

@@ -1,14 +1,14 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-GJTIZQGJ.js";
-import "./chunk-7MHNIGHP.js";
+} from "./chunk-NRMAOGRS.js";
+import "./chunk-64WF2GQ3.js";
 import "./chunk-CEMMLV5L.js";
 import "./chunk-N7TMSOZH.js";
 import "./chunk-DWPN6SCH.js";
 import "./chunk-TXKUKMVO.js";
-import "./chunk-OMQ2J6F6.js";
+import "./chunk-3CVEE6LA.js";
 import "./chunk-PEQXYSSE.js";
-import "./chunk-7GAP2XG4.js";
+import "./chunk-YXSBZRP7.js";
 export {
   pluginCatalogRuntime
 };

package/dist/chat/api-turns/mailbox-input.d.ts

@@ -0,0 +1,7 @@
+/** Shared mailbox helpers for conversation-only turns. */
+import type { LocalActor } from "@/chat/actor";
+import type { InboundMessage } from "@/chat/task-execution/store";
+/** Join non-empty mailbox texts for one conversation-only turn. */
+export declare function joinMailboxText(messages: readonly InboundMessage[]): string;
+/** Local actor stamped on resource-event conversation-only turns. */
+export declare function localResourceEventActor(): LocalActor;

package/dist/chat/api-turns/routing.d.ts

@@ -10,15 +10,27 @@ declare const apiTurnMailboxMetadataSchema: z.ZodObject<{
     messageId: z.ZodString;
 }, z.core.$strict>;
 export type ApiTurnMailboxMetadata = z.output<typeof apiTurnMailboxMetadataSchema>;
+/**
+ * Local destination resource-event mailbox rows share the conversation-only runner.
+ *
+ * TODO(resource-events): Remove the dedicated `resource_event` work kind once
+ * local/web destinations run plain mailbox system wakes the same way as any
+ * other deferred conversation turn (no special batch/actor fork).
+ */
+export type LocalResourceEventMailboxEntry = {
+    message: InboundMessage;
+    kind: "resource_event";
+};
 /** Return the active root API Turn for one Conversation, if it has one. */
 export declare function getActiveApiTurnId(conversationId: string): Promise<string | undefined>;
 /** Return the idle auth-paused root API Turn for one Conversation. */
 export declare function getAuthPausedApiTurnId(conversationId: string): Promise<string | undefined>;
 /**
- * Resolve API Turn work from mailbox metadata or an active checkpoint.
+ * Resolve conversation-only work from mailbox metadata or an active checkpoint.
  *
- * Empty resume wakes after yield carry no mailbox rows. Use durable active
- * Turn state so these wakes do not fall through to Slack.
+ * Covers dashboard API turns and local destination resource-event wakes. Empty
+ * resume wakes after yield carry no mailbox rows; durable active Turn state keeps
+ * those wakes on this runner instead of falling through to Slack.
  */
 export declare function resolveApiTurnWork(context: ConversationWorkerContext): Promise<{
     kind: "mailbox";
@@ -26,6 +38,9 @@ export declare function resolveApiTurnWork(context: ConversationWorkerContext):
         message: InboundMessage;
         metadata: ApiTurnMailboxMetadata;
     }>;
+} | {
+    kind: "resource_event";
+    batch: LocalResourceEventMailboxEntry[];
 } | {
     kind: "resume";
     turnId: string;

package/dist/chat/conversations/turn-lifecycle.d.ts

@@ -40,3 +40,5 @@ export declare class ConversationTurnLifecycleService implements ConversationTur
     /** Record a classified failure once. Do not store raw error text. */
     fail(input: FailConversationTurnInput): Promise<void>;
 }
+/** Return the Turn lifecycle that records Conversation events. */
+export declare function getTurnLifecycle(): ConversationTurnLifecycle;

package/dist/chat/providers/slack/runtime.d.ts

@@ -10,7 +10,6 @@ import type { Message, MessageContext, Thread } from "chat";
 import type { Destination } from "@sentry/junior-plugin-api";
 import type { SubscribedReplyDecision, SubscribedReplyPolicy } from "@/chat/services/subscribed-reply-policy";
 import { type PrepareTurnStateInput, type QueuedTurnMessage, type TurnMessageText, type TurnToolInvocation } from "@/chat/runtime/turn-input";
-import type { FailConversationTurnInput } from "@/chat/conversations/turn-lifecycle";
 export interface AssistantLifecycleEvent {
     channelId: string;
     context?: {
@@ -55,7 +54,6 @@ export interface SlackTurnRuntimeDependencies<TPreparedState> {
         threadId: string;
         threadTs: string;
     }) => Promise<void>;
-    failConversationTurn: (input: FailConversationTurnInput) => Promise<void>;
     refreshAssistantThreadContext: (event: {
         channelId: string;
         sourceChannelId?: string;

package/dist/chat/providers/slack/turn.d.ts

@@ -12,7 +12,6 @@ import type { PreparedTurnState } from "@/chat/runtime/turn-preparation";
 import { type PrepareTurnStateInput, type QueuedTurnMessage, type TurnToolInvocation } from "@/chat/runtime/turn-input";
 import type { ContextCompactor } from "@/chat/services/context-compaction";
 import type { PausedTurns } from "@/chat/task-execution/turn-wake";
-import type { ConversationTurnLifecycle } from "@/chat/conversations/turn-lifecycle";
 import { type ScheduleSessionCompletedPluginTasksOptions } from "@/chat/plugins/task-runner";
 import type { DispatchTurnContext, DispatchTurnResult } from "@/chat/agent-dispatch/types";
 interface SlackTurnDeps {
@@ -35,7 +34,6 @@ interface SlackTurnDeps {
     }>>;
     prepareTurnState: (args: PrepareTurnStateInput) => Promise<PreparedTurnState>;
     sendPluginTask?: ScheduleSessionCompletedPluginTasksOptions["send"];
-    turnLifecycle: Pick<ConversationTurnLifecycle, "fail" | "start">;
 }
 /** Build the Slack caller that prepares input and delivers output for a Turn. */
 export declare function createSlackTurn(deps: SlackTurnDeps): (thread: Thread, message: Message, options: {

package/dist/chat/resource-events/actor.d.ts

@@ -1,5 +1,10 @@
-/** Synthetic Slack author id stamped on resource-event mailbox messages. */
-export declare const RESOURCE_EVENT_SLACK_AUTHOR_ID = "UJRNEVENT";
+/**
+ * Synthetic author id stamped on resource-event mailbox messages.
+ *
+ * Kept stable so provider adapters and conversation history can recognize the
+ * same system input for resource-event turns.
+ */
+export declare const RESOURCE_EVENT_AUTHOR_ID = "UJRNEVENT";
 /** System execution actor for every resource-event turn. */
 export declare const RESOURCE_EVENT_SYSTEM_ACTOR: {
     readonly platform: "system";

package/dist/chat/resource-events/app-publisher.d.ts

@@ -0,0 +1,18 @@
+import type { ResourceEvent } from "@sentry/junior-plugin-api";
+import type { StateAdapter } from "chat";
+import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
+export type ResourceEventAppPublisher = {
+    neededMatchKeys(input: {
+        eventTypes: string[];
+        identifiers: string[];
+        namespace: string;
+    }): Promise<string[]>;
+    publish(event: ResourceEvent): Promise<void>;
+};
+/** Build the core resource-event publisher used by plugin routes. */
+export declare function createResourceEventAppPublisher(args: {
+    conversationWork: () => {
+        queue?: ConversationWorkQueue;
+        state?: StateAdapter;
+    };
+}): ResourceEventAppPublisher;

package/dist/chat/resource-events/catalog.d.ts

@@ -2,6 +2,25 @@ import { type PluginResourceEvents, type ResourceEventMatch, type ResourceEventM
 import { z } from "zod";
 type ResourceEventRegistration = Pick<PluginResourceEvents, "resourceTypes" | "normalizeIdentifier">;
 export type ResourceEventCatalog = Readonly<Record<string, ResourceEventRegistration>>;
+/** Core-owned resource-event namespace. Not a plugin publisher. */
+export declare const CORE_RESOURCE_EVENT_NAMESPACE = "junior";
+/** True when the catalog has any enabled registration. */
+export declare function hasResourceEventCatalogEntries(catalog: ResourceEventCatalog): boolean;
+/**
+ * True when at least one plugin namespace is enabled.
+ *
+ * Core Workspace snapshot events stay in the catalog for search and temporary
+ * watches. Durable event tasks still require a plugin publisher.
+ */
+export declare function hasPluginResourceEventCatalogEntries(catalog: ResourceEventCatalog): boolean;
+/**
+ * Catalog entries that durable event tasks may select.
+ *
+ * Core Workspace snapshot events only wake temporary watches. Snapshot finish
+ * does not run event-task ingest, so those namespaces stay out of create/update
+ * schemas and trigger availability.
+ */
+export declare function pluginResourceEventCatalog(catalog: ResourceEventCatalog): ResourceEventCatalog;
 /** Build the model-facing namespace enum from enabled resource event plugins. */
 export declare function eventNamespaceSchema(catalog: ResourceEventCatalog): z.ZodString | z.ZodEnum<{
     [x: string]: string;

package/dist/chat/resource-events/ingest.d.ts

@@ -5,7 +5,6 @@ export declare function ingestResourceEvent(input: unknown, options: {
     nowMs?: number;
     queue: ConversationWorkQueue;
     state?: StateAdapter;
-    teamId: string;
 }): Promise<{
     enqueued: number;
 }>;

package/dist/chat/resource-events/notification.d.ts

@@ -1,5 +1,5 @@
 import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
-import { appendAndEnqueueInboundMessage } from "@/chat/task-execution/store";
+import { appendAndEnqueueInboundMessage, type AppendAndEnqueueInboundMessageResult, type InboundMessage } from "@/chat/task-execution/store";
 import type { ResourceEventSubscription } from "@/chat/resource-events/store";
 export interface ResourceEventNotification {
     eventKey: string;
@@ -19,10 +19,35 @@ export interface ResourceEventNotification {
  * contract. Stable delivery rules live in runtime and docs, not this prompt.
  */
 export declare function renderResourceEventNotificationText(subscription: Pick<ResourceEventSubscription, "intent" | "label" | "resourceType">, event: Pick<ResourceEventNotification, "namespace" | "eventType" | "trustedSummary" | "data" | "untrustedText">): string;
-/** Enqueue a resource event as normal conversation mailbox input. */
+/** Resource-event identity stamped on plain mailbox input. */
+export type ResourceEventMailboxMetadata = {
+    kind: "resource_event";
+    resourceEvent: {
+        eventKey: string;
+        eventType: string;
+        namespace: string;
+        identifier: string;
+        subscriptionId: string;
+    };
+} & Record<string, unknown>;
+/** Whether mailbox metadata is a plain resource-event wake. */
+export declare function isResourceEventMailboxMetadata(value: unknown): value is ResourceEventMailboxMetadata;
+/** Build plain conversation mailbox input for one matched watch. */
+export declare function createResourceEventInboundMessage(input: {
+    event: ResourceEventNotification;
+    subscription: Pick<ResourceEventSubscription, "conversationId" | "id">;
+    text: string;
+    receivedAtMs?: number;
+}): InboundMessage;
+/**
+ * Enqueue a resource event as normal conversation mailbox input.
+ *
+ * The watch only names the conversation. Destination stays on the conversation
+ * and is applied when the worker runs.
+ */
 export declare function enqueueResourceEventNotification(args: {
     event: ResourceEventNotification;
     queue: ConversationWorkQueue;
     subscription: ResourceEventSubscription;
     state?: Parameters<typeof appendAndEnqueueInboundMessage>[0]["state"];
-}): Promise<Awaited<ReturnType<typeof appendAndEnqueueInboundMessage>>>;
+}): Promise<AppendAndEnqueueInboundMessageResult>;

package/dist/chat/resource-events/runtime-catalog.d.ts

@@ -1,3 +1,8 @@
-import type { ResourceEventCatalog } from "@/chat/resource-events/catalog";
-/** Read enabled plugin resource-event registrations as one core catalog. */
+import { type ResourceEventCatalog } from "@/chat/resource-events/catalog";
+/**
+ * Enabled resource-event registrations for search, guidance, and tool schemas.
+ *
+ * Includes core Workspace snapshot events under the `junior` namespace, plus
+ * every enabled plugin registration. Plugins may not use the `junior` namespace.
+ */
 export declare function getResourceEventCatalog(): ResourceEventCatalog;

package/dist/chat/resource-events/store.d.ts

@@ -1,17 +1,9 @@
 import type { StateAdapter } from "chat";
-import { type Destination, type ResourceEventData, type ResourceEventMatch } from "@sentry/junior-plugin-api";
+import { type ResourceEventData, type ResourceEventMatch } from "@sentry/junior-plugin-api";
 import { z } from "zod";
 declare const subscriptionSchema: z.ZodObject<{
     conversationId: z.ZodString;
     createdAtMs: z.ZodNumber;
-    destination: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        platform: z.ZodLiteral<"slack">;
-        teamId: z.ZodString;
-        channelId: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        platform: z.ZodLiteral<"local">;
-        conversationId: z.ZodString;
-    }, z.core.$strict>], "platform">;
     events: z.ZodArray<z.ZodString>;
     expiresAtMs: z.ZodNumber;
     id: z.ZodString;
@@ -31,7 +23,6 @@ declare const subscriptionSchema: z.ZodObject<{
 export type ResourceEventSubscription = z.output<typeof subscriptionSchema>;
 export interface CreateResourceEventSubscriptionInput {
     conversationId: string;
-    destination: Destination;
     events: string[];
     expiresAtMs: number;
     intent: string;
@@ -75,7 +66,6 @@ export declare function collectResourceEventMatchKeys(input: {
     namespace: string;
     nowMs?: number;
     state?: StateAdapter;
-    teamId: string;
 }): Promise<string[]>;
 /** Find active subscriptions interested in a normalized resource event. */
 export declare function findMatchingResourceEventSubscriptions(input: {
@@ -85,7 +75,6 @@ export declare function findMatchingResourceEventSubscriptions(input: {
     namespace: string;
     identifier: string;
     state?: StateAdapter;
-    teamId: string;
 }): Promise<ResourceEventSubscription[]>;
 /** Recheck and deliver a matched subscription while holding its status lock. */
 export declare function deliverResourceEventSubscription(input: {
@@ -97,7 +86,6 @@ export declare function deliverResourceEventSubscription(input: {
     identifier: string;
     state?: StateAdapter;
     subscription: ResourceEventSubscription;
-    teamId: string;
     terminal?: boolean;
     waitDeadlineMs?: number;
 }): Promise<boolean>;

package/dist/chat/resource-events/workspace.d.ts

@@ -1,4 +1,8 @@
-/** Return whether provider events can be bound to one Slack workspace. */
-export declare function canRouteResourceEvents(): boolean;
-/** Resolve and cache the Slack workspace owned by this app instance. */
+/**
+ * Resolve the single-bot Slack team id for event-task indexing.
+ *
+ * Resource watches do not use this. Event tasks still key by destination team
+ * until that store is conversation-owned. Resource-event delivery itself is
+ * not gated on Slack.
+ */
 export declare function createResourceEventTeamIdResolver(): () => Promise<string | undefined>;

package/dist/chat/sandbox/egress/credentials.d.ts

@@ -49,11 +49,12 @@ export declare function selectSandboxEgressGrant(input: {
  */
 export declare function authorizationForSandboxEgressGrant(provider: string, selection: SandboxEgressGrantSelection): PluginAuthorization | undefined;
 /**
- * Return cached or newly issued credential header transforms for a selected grant.
+ * Return credential header transforms for a selected grant.
  *
- * Leases are cached on the host by provider grant, validated against
- * provider-owned domains, and reused until the provider lease is near expiry.
- * Sandbox context only authorizes the hop.
+ * Only shared installation grants are remembered on the host. User and other
+ * grants always issue from the live credential source so a saved login change
+ * cannot leave stale auth headers in place. The sandbox context only authorizes
+ * the request.
  */
 export declare function sandboxEgressCredentialLease(provider: string, selection: SandboxEgressGrantSelection, context: SandboxEgressCredentialContext): Promise<SandboxEgressCredentialLease>;
 /** Return whether a credential lease can modify requests to the target host. */

package/dist/chat/sandbox/egress/session.d.ts

@@ -22,17 +22,17 @@ export declare function createSandboxEgressCredentialToken(input: {
  */
 export declare function parseSandboxEgressCredentialToken(token: string | undefined): SandboxEgressCredentialContext | undefined;
 /**
- * Cache credential header transforms for one provider grant.
+ * Remember auth headers for a shared installation grant.
  *
- * TTL follows the provider lease expiry. Sandbox context expiry still decides
- * whether a hop may use the cache; it does not shorten a shared installation
- * lease for other sandboxes.
+ * User and other grants are ignored here. TTL follows the provider expiry.
+ * Sandbox context expiry still decides whether a request may use the headers;
+ * it does not shorten a shared installation grant for other sandboxes.
  */
-export declare function setSandboxEgressCredentialLease(context: SandboxEgressCredentialContext, lease: SandboxEgressCredentialLease): Promise<void>;
-/** Load cached credential header transforms for one provider grant. */
-export declare function getSandboxEgressCredentialLease(provider: string, grant: SandboxEgressCredentialLease["grant"], context: SandboxEgressCredentialContext): Promise<SandboxEgressCredentialLease | undefined>;
-/** Clear a cached lease after the upstream provider rejects its auth headers. */
-export declare function clearSandboxEgressCredentialLease(provider: string, grant: SandboxEgressCredentialLease["grant"], context: SandboxEgressCredentialContext): Promise<void>;
+export declare function setSandboxEgressCredentialLease(_context: SandboxEgressCredentialContext, lease: SandboxEgressCredentialLease): Promise<void>;
+/** Load remembered auth headers for a shared installation grant. */
+export declare function getSandboxEgressCredentialLease(provider: string, grant: SandboxEgressCredentialLease["grant"], _context: SandboxEgressCredentialContext): Promise<SandboxEgressCredentialLease | undefined>;
+/** Drop remembered installation headers after the upstream rejects them. */
+export declare function clearSandboxEgressCredentialLease(provider: string, grant: SandboxEgressCredentialLease["grant"], _context: SandboxEgressCredentialContext): Promise<void>;
 /**
  * Record that credential issuance needs user authorization for this command.
  *

package/dist/chat/sandbox/errors.d.ts

@@ -12,7 +12,7 @@ export declare function isAbortError(error: unknown): boolean;
 export declare function isSandboxApiTransientError(error: unknown): boolean;
 /** Detect interrupted command streams where no reliable exit status is available. */
 export declare function isSandboxCommandStreamInterruptedError(error: unknown): boolean;
-/** Wrap raw sandbox setup failures into one stable user-facing error contract. */
+/** Wrap setup failures. Keep WorkspaceSnapshotNotReadyError as-is. */
 export declare function wrapSandboxSetupError(error: unknown): Error;
 /** Record span data and throw one stable sandbox operation error. */
 export declare function throwSandboxOperationError(action: string, error: unknown, includeMissingPath?: boolean): never;

package/dist/chat/sandbox/ref.d.ts

@@ -1,4 +1,4 @@
-/** Durable opaque handle used to reopen a conversation's sandbox. */
+/** Sandbox this conversation is using. Reopen by `id`; only switchWorkspace replaces it. */
 export interface SandboxRef {
     id: string;
     profileHash?: string;

package/dist/chat/sandbox/snapshot/events.d.ts

@@ -1,8 +1,15 @@
-import type { ResourceEvent, SubscribableResource } from "@sentry/junior-plugin-api";
+import type { PluginResourceEvents, ResourceEvent, SubscribableResource } from "@sentry/junior-plugin-api";
 export declare const WORKSPACE_SNAPSHOT_NAMESPACE = "junior";
 export declare const WORKSPACE_SNAPSHOT_RESOURCE_TYPE = "workspace_snapshot";
 export declare const WORKSPACE_SNAPSHOT_READY_EVENT = "workspace_snapshot.ready";
 export declare const WORKSPACE_SNAPSHOT_FAILED_EVENT = "workspace_snapshot.failed";
+/**
+ * Core catalog entry for Workspace snapshot ready and failed events.
+ *
+ * Uses the same registration shape as plugins so search, guidance, and tool
+ * schemas treat these events like any other resource type.
+ */
+export declare function workspaceSnapshotResourceEvents(): PluginResourceEvents;
 /** Describe the events that report when a snapshot build ends. */
 export declare function workspaceSnapshotWatch(input: {
     workspaceId: string;

package/dist/chat/sandbox/snapshot/not-ready-error.d.ts

@@ -1,6 +1,11 @@
 /** Report that a Workspace snapshot is not ready to use. */
 export declare class WorkspaceSnapshotNotReadyError extends Error {
+    readonly workspaceName: string;
     constructor(workspaceName: string);
 }
-/** Check an error and its causes for a snapshot that is not ready. */
+/** Return WorkspaceSnapshotNotReadyError from this error or its causes. */
+export declare function getWorkspaceSnapshotNotReadyError(error: unknown): WorkspaceSnapshotNotReadyError | undefined;
+/** True when this error or a cause is WorkspaceSnapshotNotReadyError. */
 export declare function isWorkspaceSnapshotNotReadyError(error: unknown): boolean;
+/** User message when a Workspace sandbox is still preparing. */
+export declare function workspaceSnapshotNotReadyUserMessage(error: WorkspaceSnapshotNotReadyError): string;

package/dist/chat/sentry-links.d.ts

@@ -1,4 +1,6 @@
 /** Build a Sentry conversation URL only when the runtime has enough Sentry config. */
 export declare function buildSentryConversationUrl(conversationId: string): string | undefined;
+/** Build a Sentry event URL only when the runtime has enough Sentry config. */
+export declare function buildSentryEventUrl(eventId: string): string | undefined;
 /** Build a Sentry trace URL only when the runtime has enough Sentry config. */
 export declare function buildSentryTraceUrl(traceId: string): string | undefined;

package/dist/chat/services/turn-session-routing.d.ts

@@ -1,18 +1,33 @@
 /**
- * Load turn-session routing from durable conversation metadata.
+ * Load destination and session source from the conversation record.
  *
- * SQL owns destination and session source. Resume paths query those columns
- * directly — no redis fallback and no derived rebuild of missing fields.
+ * Destination is set once on the root conversation. Child conversations
+ * inherit through parent lineage. Later turns and mailbox wakes use that
+ * same destination so tools stay consistent for the whole conversation.
  */
 import type { Destination, Source } from "@sentry/junior-plugin-api";
 import type { ConversationStore } from "@/chat/conversations/store";
 export interface TurnSessionRouting {
     destination: Destination;
     locationId?: string;
-    source: Source;
+    /** Present when the conversation already stores a session source. */
+    source?: Source;
 }
+/** Full turn routing: destination plus a completed session source. */
+export type RequiredTurnSessionRouting = TurnSessionRouting & {
+    source: Source;
+};
+/**
+ * Resolve the conversation's destination and session source.
+ *
+ * Walks parent lineage when the conversation has no destination of its own.
+ */
+export declare function resolveConversationRouting(args: {
+    conversationId: string;
+    conversationStore?: ConversationStore;
+}): Promise<TurnSessionRouting | undefined>;
 /** Require conversation destination and session source from SQL. */
 export declare function resolveTurnSessionRouting(args: {
     conversationId: string;
     conversationStore?: ConversationStore;
-}): Promise<TurnSessionRouting>;
+}): Promise<RequiredTurnSessionRouting>;

package/dist/chat/task-execution/slack-resource-event.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Slack edge helpers for resource-event mailbox wakes.
+ *
+ * Resource-event ingest stores plain conversation mailbox input. When the
+ * conversation destination is Slack, this module builds the Message and Thread
+ * the Slack runtime needs for one turn. It does not rewrite mailbox rows.
+ *
+ * TODO(slack-runtime): Drop this module once Slack turns can start from
+ * conversation destination + session source (channel, team, threadTs, text,
+ * event metadata) without a synthetic chat Message/Thread. Resource wakes and
+ * paused resume should share that entry; handleSubscribedMessage stays for
+ * real webhook traffic only.
+ */
+import { Message, ThreadImpl, type StateAdapter } from "chat";
+import type { SlackAdapter } from "@chat-adapter/slack";
+import type { Destination, SlackDestination } from "@sentry/junior-plugin-api";
+import type { ConversationStore } from "@/chat/conversations/store";
+import type { InboundMessage } from "@/chat/task-execution/store";
+/** Load Slack destination and threadTs for a resource-event wake. */
+export declare function resolveSlackResourceEventThread(args: {
+    conversationId: string;
+    conversationStore?: ConversationStore;
+    destination?: Destination;
+}): Promise<{
+    destination: SlackDestination;
+    threadTs: string;
+}>;
+/** Whether a mailbox row is a plain resource-event wake (no Slack envelope). */
+export declare function isPlainResourceEventRecord(record: InboundMessage): boolean;
+/**
+ * Build a Slack Message for one plain resource-event mailbox row.
+ *
+ * Used only at the Slack worker edge. The mailbox row stays plain.
+ */
+export declare function buildResourceEventSlackMessage(args: {
+    channelId: string;
+    record: InboundMessage;
+    threadTs: string;
+}): Message;
+/** Build a ThreadImpl for a resource-event Slack turn. */
+export declare function buildResourceEventSlackThread(args: {
+    adapter: SlackAdapter;
+    message: Message;
+    state: StateAdapter;
+    threadTs: string;
+    channelId: string;
+}): ThreadImpl;

package/dist/chat/task-execution/slack-work.d.ts

@@ -251,25 +251,6 @@ interface SlackInboxTurnRuntime {
     handleNewMention(thread: ThreadImpl, message: Message, hooks: SlackInboxTurnOptions): Promise<void>;
     handleSubscribedMessage(thread: ThreadImpl, message: Message, hooks: SlackInboxTurnOptions): Promise<void>;
 }
-interface SlackResourceEventInboundInput {
-    event: {
-        eventKey: string;
-        eventType: string;
-        occurredAtMs: number;
-        namespace: string;
-        identifier: string;
-    };
-    subscription: {
-        conversationId: string;
-        destination: {
-            channelId: string;
-            platform: "slack";
-            teamId: string;
-        };
-        id: string;
-    };
-    text: string;
-}
 export interface CreateSlackConversationWorkerOptions {
     crossActorMidRunMode?: CrossActorMidRunMode;
     getSlackAdapter: () => SlackAdapter;
@@ -281,8 +262,6 @@ export interface CreateSlackConversationWorkerOptions {
     runtime: SlackInboxTurnRuntime;
     state?: StateAdapter;
 }
-/** Create a Slack mailbox record for a subscribed resource-event notification. */
-export declare function createSlackResourceEventInboundMessage(input: SlackResourceEventInboundInput): InboundMessage;
 /** Build the worker run function for queued Slack conversation work. */
 export declare function createSlackConversationWorker(options: CreateSlackConversationWorkerOptions): (context: ConversationWorkerContext) => Promise<ConversationWorkerResult>;
 /** Serialize a Slack message into the generic durable conversation mailbox. */

package/dist/chat/tools/event-tasks.d.ts

@@ -1,4 +1,4 @@
-import type { ResourceEventCatalog } from "@/chat/resource-events/catalog";
+import { type ResourceEventCatalog } from "@/chat/resource-events/catalog";
 import type { ToolRegistry } from "@/chat/tools/definition";
 import type { ToolRuntimeContext } from "@/chat/tools/types";
 /** Build event task tools for an interactive Slack actor. */

package/dist/chat/tools/resource-events.d.ts

@@ -1,4 +1,4 @@
-import type { ResourceEventCatalog } from "@/chat/resource-events/catalog";
+import { type ResourceEventCatalog } from "@/chat/resource-events/catalog";
 import type { ToolRegistry } from "@/chat/tools/definition";
 import type { ToolRuntimeContext } from "@/chat/tools/types";
 /** Build the complete resource-watch tool set for this runtime context. */

package/dist/{chunk-D63IUQQE.js → chunk-2IBDVE62.js}

@@ -8,14 +8,14 @@ import {
   getConversationStore,
   parseDestination,
   sameDestination
-} from "./chunk-ABAX75GG.js";
+} from "./chunk-43LODHJM.js";
 import {
   getDefaultRedisStateAdapterFor,
   getStateAdapter
-} from "./chunk-PNYJOEVV.js";
+} from "./chunk-DOP3FIQC.js";
 import {
   getChatConfig
-} from "./chunk-LRI5IRGY.js";
+} from "./chunk-AD64YMEC.js";
 import {
   parseStoredSlackActor
 } from "./chunk-N7TMSOZH.js";
@@ -23,7 +23,7 @@ import {
   isRecord,
   toOptionalNumber,
   toOptionalString
-} from "./chunk-OMQ2J6F6.js";
+} from "./chunk-3CVEE6LA.js";
 
 // src/chat/task-execution/state.ts
 import { randomUUID } from "crypto";
@@ -248,9 +248,12 @@ function normalizeConversation(conversationId, value) {
   if (storedConversationId !== conversationId || typeof createdAtMs !== "number" || typeof lastActivityAtMs !== "number" || typeof updatedAtMs !== "number" || !execution || value.destination !== void 0 && !destination) {
     return void 0;
   }
-  if (execution.pendingMessages.length > 0 && execution.pendingMessages.some(
-    (message) => message.destination ? !destination || !sameDestination(message.destination, destination) : Boolean(destination)
-  )) {
+  if (execution.pendingMessages.length > 0 && execution.pendingMessages.some((message) => {
+    if (!message.destination) {
+      return false;
+    }
+    return !destination || !sameDestination(message.destination, destination);
+  })) {
     return void 0;
   }
   return {
@@ -636,10 +639,10 @@ async function writeConversation(state, lock, conversation) {
   });
 }
 function assertSameOptionalConversationDestination(args) {
-  if (!args.current && !args.next) {
+  if (!args.next || !args.current) {
     return;
   }
-  if (args.current && args.next && sameDestination(args.current, args.next)) {
+  if (sameDestination(args.current, args.next)) {
     return;
   }
   throw new Error(