@sentry/junior 0.185.0 → 0.187.0

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

@@ -1,14 +1,14 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-GJTIZQGJ.js";
-import "./chunk-7MHNIGHP.js";
+} from "./chunk-QH3I7ZOK.js";
+import "./chunk-X5SXFVZT.js";
 import "./chunk-CEMMLV5L.js";
 import "./chunk-N7TMSOZH.js";
 import "./chunk-DWPN6SCH.js";
 import "./chunk-TXKUKMVO.js";
-import "./chunk-OMQ2J6F6.js";
+import "./chunk-6YCIYOVA.js";
 import "./chunk-PEQXYSSE.js";
-import "./chunk-7GAP2XG4.js";
+import "./chunk-7LRRVMPH.js";
 export {
   pluginCatalogRuntime
 };

package/dist/chat/agent/types.d.ts

@@ -1,13 +1,8 @@
-/**
- * Public agent-run launch contract.
- *
- * Providers build one flat `AgentRun` and call `AgentRunner.run`. Delivery and
- * durability are capabilities that affect the run. `onEvent` is best-effort UI
- * only. Stable composition binds stream, spawn, and tracing outside this type.
- */
+/** Input for one Run through Junior's agent. */
 import type { Destination, ReplyAttribution, Source, SystemActor } from "@sentry/junior-plugin-api";
 import type { LocationConfigurationService } from "@/chat/configuration/types";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
+import type { Location } from "@/chat/conversations/location";
 import type { CredentialContext } from "@/chat/credentials/context";
 import type { PiMessage } from "@/chat/pi/messages";
 import type { Actor } from "@/chat/actor";
@@ -38,7 +33,8 @@ export type AgentInstructionActor = {
     authorName?: string;
     /**
      * Slack message ts for the instruction when known.
-     * TODO: generalize to a provider-neutral message id once prompt attrs are neutral.
+     * TODO(dcramer): Use a provider-neutral message id after prompt attributes no
+     * longer require the Slack timestamp.
      */
     slackTs?: string;
 };
@@ -153,7 +149,7 @@ export type AgentEnvironment = {
     };
 };
 /**
- * One provider-launched agent-run slice.
+ * One bounded attempt to advance a Turn.
  *
  * Build identity, instruction, history, delivery, and durability here. Bind
  * stable model/stream composition when creating the runner, not on each run.
@@ -177,6 +173,13 @@ export type AgentRun = {
     /** Credential authority projected from actor (plus optional subject). */
     credentialContext?: CredentialContext;
     source: Source;
+    /**
+     * Transitional Conversation Location for this Run.
+     * TODO(dcramer): Remove top-level Location, Destination, and
+     * publishExternally after Source and Delivery contain Location across new,
+     * resumed, and child Runs.
+     */
+    location?: Location;
     destination: Destination;
     /** When true, also publish assistant output to the conversation destination. */
     publishExternally?: boolean;
@@ -185,7 +188,7 @@ export type AgentRun = {
     surface?: AgentTurnSurface;
     dispatch?: AgentDispatch;
     /**
-     * TODO: Move ephemeral Slack credentials and conversation labels into
+     * TODO(dcramer): Move ephemeral Slack credentials and conversation labels into
      * provider-owned tool/prompt context so the shared run edge stays neutral.
      */
     slackConversation?: SlackConversationContext;
@@ -197,9 +200,9 @@ export type AgentRun = {
      * Optional agent capabilities disabled for this run slice.
      * `interactive-auth` blocks pausing to send an OAuth link; missing credentials
      * hard-fail instead. Default is enabled when omitted.
-     * TODO(#881, #883): child invocations currently disable interactive-auth, but
-     * may later need a path to force the auth flow when a delegated tool requires
-     * credentials the parent can already request.
+     * TODO(dcramer): Issues #881 and #883 track a path for child invocations to
+     * force interactive auth when a delegated tool requires credentials the
+     * parent can already request. Children currently disable it.
      */
     disabledFeatures?: readonly AgentFeature[];
     /** Absolute wall-clock deadline for this host request, in milliseconds. */

package/dist/chat/api-turns/{accepted-reply.d.ts → assistant-message.d.ts}

@@ -1,11 +1,12 @@
 import type { AssistantMessage } from "@earendil-works/pi-ai";
 import type { ThreadConversationState } from "@/chat/state/conversation";
-/** Record a web-accepted assistant reply with agent history before the visible message. */
-export declare function commitWebAcceptedReply(args: {
+/** Store one assistant Message and its Agent history. */
+export declare function commitAssistantMessage(args: {
     agentMessage?: AssistantMessage;
     conversation: ThreadConversationState;
     conversationId: string;
     sessionId: string;
+    source?: "web";
     text: string;
     userMessageId: string;
 }): Promise<void>;

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

@@ -12,7 +12,6 @@ export declare function createApiTurnCancellation(): ApiTurnCancellation;
 /** Close one cancelled Turn without a failure reply or retry. */
 export declare function completeCancelledApiTurn(args: {
     acknowledge(): Promise<void>;
-    actorId: string;
     cancellation?: ApiTurnCancellation;
     conversation: ThreadConversationState;
     conversationId: string;

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

@@ -0,0 +1,4 @@
+/** Shared mailbox helpers for conversation-only turns. */
+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;

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

@@ -1,4 +1,8 @@
 import { z } from "zod";
+import { type Source } from "@sentry/junior-plugin-api";
+import { type Actor } from "@/chat/actor";
+import type { ConversationPrivacy } from "@/chat/conversation-privacy";
+import type { ConversationAuthor, ConversationMessage } from "@/chat/state/conversation";
 import type { InboundMessage } from "@/chat/task-execution/store";
 import type { ConversationWorkerContext } from "@/chat/task-execution/worker";
 declare const apiTurnMailboxMetadataSchema: z.ZodObject<{
@@ -10,22 +14,34 @@ declare const apiTurnMailboxMetadataSchema: z.ZodObject<{
     messageId: z.ZodString;
 }, z.core.$strict>;
 export type ApiTurnMailboxMetadata = z.output<typeof apiTurnMailboxMetadataSchema>;
+export interface TurnInput {
+    actor: Actor;
+    author: ConversationAuthor;
+    message: InboundMessage;
+    source: "resource_event" | "web";
+}
+export type TurnIdentity = Pick<TurnInput, "actor" | "author" | "source">;
+/** Restore normalized Turn identity from one saved Message. */
+export declare function turnIdentityFromConversationMessage(message: ConversationMessage): TurnIdentity | undefined;
+/** Build the AgentRun Source for one Turn input. */
+export declare function sourceFromTurnInput(args: {
+    conversationId: string;
+    source: TurnInput["source"];
+    visibility?: ConversationPrivacy;
+}): Source;
 /** 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 new input or a saved Turn.
  *
- * Empty resume wakes after yield carry no mailbox rows. Use durable active
- * Turn state so these wakes do not fall through to Slack.
+ * User messages from the Conversation API run here. Resource events with a
+ * local Destination run here too. Saved state identifies a resumed Turn.
  */
 export declare function resolveApiTurnWork(context: ConversationWorkerContext): Promise<{
     kind: "mailbox";
-    batch: Array<{
-        message: InboundMessage;
-        metadata: ApiTurnMailboxMetadata;
-    }>;
+    batch: TurnInput[];
 } | {
     kind: "resume";
     turnId: string;

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

@@ -1,7 +1,7 @@
 import type { StateAdapter } from "chat";
 import { type Destination } from "@sentry/junior-plugin-api";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
-import type { WebActor } from "@/chat/actor";
+import { type WebActor } from "@/chat/actor";
 import type { ConversationStore } from "@/chat/conversations/store";
 import type { AgentRunner } from "@/chat/runtime/agent-runner";
 import { type InboundMessage } from "@/chat/task-execution/store";
@@ -90,7 +90,7 @@ export declare function appendAndEnqueueApiConversationMessage(input: AppendApiC
     exclusive: true;
 }): Promise<ApiConversationMessageAdmission>;
 export declare function appendAndEnqueueApiConversationMessage(input: AppendApiConversationMessageInput, options: EnqueueOptions): Promise<ApiConversationMessageAccepted>;
-/** Create the worker for messages from the Conversation API. */
+/** Create the worker for Turns that need no provider delivery. */
 export declare function createApiTurnWorker(agentRunner: AgentRunner, cancellation?: ApiTurnCancellation): (context: ConversationWorkerContext) => Promise<ConversationWorkerResult>;
 /** Route Conversation API work before other work. */
 export declare function routeApiTurnWork(options: {

package/dist/chat/conversations/location.d.ts

@@ -1,10 +1,10 @@
 import { z } from "zod";
-/** Provider-neutral container associated with a conversation. */
+/** One place outside Junior where a Conversation can be delivered. */
 export declare const locationSchema: z.ZodObject<{
     id: z.ZodString;
     provider: z.ZodString;
     tenantId: z.ZodOptional<z.ZodString>;
     providerId: z.ZodString;
 }, z.core.$strict>;
-/** Validated provider location associated with a conversation. */
+/** Validated Location associated with a Conversation. */
 export type Location = z.output<typeof locationSchema>;

package/dist/chat/conversations/store.d.ts

@@ -17,6 +17,18 @@ export interface ConversationExecution {
 export interface ConversationLineage {
     parentConversationId: string;
 }
+/**
+ * Durable Conversation owned by Junior.
+ *
+ * The final interface stores zero or one complete Location here. No Location
+ * means the Conversation stays in Junior's API and UI. A Location names the
+ * outside place where a provider can deliver the Conversation. Source may also
+ * contain this Location so the agent can use it. Delivery contains it when
+ * output may be sent there. Only Delivery allows output to be sent.
+ *
+ * `destination` and `sessionSource` temporarily duplicate parts of that model.
+ * Their field TODOs state when each legacy copy can be removed.
+ */
 export interface Conversation {
     channelName?: string;
     conversationId: string;
@@ -30,6 +42,7 @@ export interface Conversation {
     };
     lastActivityAtMs: number;
     lineage?: ConversationLineage;
+    /** Optional provider coordinates associated with this Conversation. */
     location?: Location;
     actor?: StoredSlackActor;
     schemaVersion: 1;

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,17 @@
-/** 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";
+/** Synthetic Message author for resource-event input. */
+export declare const RESOURCE_EVENT_MESSAGE_AUTHOR: {
+    readonly fullName: "Junior event";
+    readonly isBot: true;
+    readonly userId: "UJRNEVENT";
+    readonly userName: "junior-event";
+};
 /** 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,34 @@
 /**
- * Load turn-session routing from durable conversation metadata.
+ * Load Location, 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";
+import type { Location } from "@/chat/conversations/location";
 export interface TurnSessionRouting {
     destination: Destination;
-    locationId?: string;
-    source: Source;
+    location?: Location;
+    /** Present when the conversation already stores a session source. */
+    source?: Source;
 }
-/** Require conversation destination and session source from SQL. */
+/** Conversation data with a required Destination and Source. */
+export type RequiredTurnSessionRouting = TurnSessionRouting & {
+    source: Source;
+};
+/**
+ * Resolve the Conversation's Location, 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 the Conversation Destination and Source from SQL. */
 export declare function resolveTurnSessionRouting(args: {
     conversationId: string;
     conversationStore?: ConversationStore;
-}): Promise<TurnSessionRouting>;
+}): Promise<RequiredTurnSessionRouting>;