@sentry/junior 0.114.0 → 0.116.0

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

@@ -33,7 +33,7 @@ export declare function loadTurnProjection(args: {
 /** Load MCP providers connected in the current agent-history version. */
 export declare function loadConnectedMcpProviders(args: ScopedConversation): Promise<string[]>;
 /**
- * Append newly stable agent steps. A shorter or changed prefix indicates
+ * Append newly stable native history items. A shorter or changed prefix indicates
  * that a caller persisted volatile Pi state; only compaction and handoff may
  * intentionally replace active model history.
  */
@@ -51,7 +51,7 @@ export declare function commitMessages(args: {
 }): Promise<{
     committedSeq: number;
     historyVersion: number;
-    /** Event sequence for every projected agent step. */
+    /** Event sequence for every projected agent history item. */
     messageSeqs: number[];
     /** Normalized durable messages after volatile runtime context is removed. */
     messages: PiMessage[];

package/dist/chat/local/credential-sync.d.ts

@@ -0,0 +1,5 @@
+import { type PluginStoredTokens } from "@sentry/junior-plugin-api";
+/** Copy a local user's provider credential to the loopback dev-server broker. */
+export declare function syncLocalOAuthCredential(provider: string, tokens: PluginStoredTokens): Promise<void>;
+/** Verify and store one credential sent by the local CLI over loopback. */
+export declare function receiveLocalOAuthCredential(request: Request): Promise<Response>;

package/dist/chat/local/oauth-relay.d.ts

@@ -0,0 +1,4 @@
+/** Create an OAuth state value that can be safely relayed to a local CLI callback. */
+export declare function createLocalOAuthState(port: number): Promise<string>;
+/** Redirect a provider callback from the public dev URL to the owning local CLI. */
+export declare function relayLocalOAuthCallback(request: Request): Promise<Response | undefined>;

package/dist/chat/mcp/oauth.d.ts

@@ -17,6 +17,7 @@ export declare function createMcpOAuthClientProvider(input: {
     toolChannelId?: string;
     configuration?: Record<string, unknown>;
     artifactState?: ThreadArtifactsState;
+    createAuthorizationState?: () => Promise<string>;
 }): Promise<StateBackedMcpOAuthClientProvider>;
 /** Exchange a callback code while guarding every shared credential mutation. */
 export declare function finalizeMcpAuthorization(provider: string, authSessionId: string, authorizationCode: string, runCredentialMutation?: <T>(mutation: () => Promise<T>) => Promise<T>): Promise<McpAuthSessionState>;

package/dist/chat/mcp/tool-manager.d.ts

@@ -8,6 +8,7 @@
  */
 import type { ImageContent, TextContent } from "@earendil-works/pi-ai";
 import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+import type { ToolAnnotations } from "@sentry/junior-plugin-api";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
 import type { SkillMetadata } from "@/chat/skills";
 import type { PluginDefinition } from "@/chat/plugins/types";
@@ -27,7 +28,7 @@ export interface ManagedMcpToolDescriptor {
     description: string;
     parameters: Record<string, unknown>;
     outputSchema?: Record<string, unknown>;
-    annotations?: Record<string, unknown>;
+    annotations?: ToolAnnotations;
     provider: string;
 }
 type ActiveMcpSkill = Pick<SkillMetadata, "name" | "pluginProvider">;

package/dist/chat/oauth-authorization.d.ts

@@ -0,0 +1,17 @@
+/** User-facing link and guidance for one OAuth authorization attempt. */
+export interface OAuthAuthorizationRequest {
+    authorizationUrl: string;
+    completionText: string;
+    label: string;
+}
+/** Surface-owned capabilities for creating and presenting OAuth authorization. */
+export interface OAuthAuthorization {
+    createState: () => Promise<string>;
+    deliver: (request: OAuthAuthorizationRequest) => void | Promise<void>;
+}
+/** Build the stable event identity shared by authorization request and completion. */
+export declare function authorizationId(args: {
+    kind: "mcp" | "plugin";
+    provider: string;
+    sessionId: string;
+}): string;

package/dist/chat/oauth-flow.d.ts

@@ -1,4 +1,5 @@
 import { type Destination, type Source } from "@sentry/junior-plugin-api";
+import type { OAuthAuthorization, OAuthAuthorizationRequest } from "@/chat/oauth-authorization";
 type PrivateDeliveryResult = "in_context" | "fallback_dm" | false;
 export type OAuthStatePayload = {
     userId: string;
@@ -21,6 +22,7 @@ type OAuthFlowInput = {
     resumeConversationId?: string;
     resumeSessionId?: string;
     scope?: string;
+    authorization?: OAuthAuthorization;
 };
 /** Parse OAuth callback state that was persisted before a provider redirect. */
 export declare function parseOAuthStatePayload(value: unknown): OAuthStatePayload | undefined;
@@ -38,6 +40,13 @@ export declare function deliverPrivateMessage(input: {
     userId: string;
     text: string;
 }): Promise<PrivateDeliveryResult>;
+/** Present one OAuth request through the active surface's private delivery. */
+export declare function deliverOAuthAuthorization(request: OAuthAuthorizationRequest, input: {
+    authorization?: OAuthAuthorization;
+    channelId?: string;
+    threadTs?: string;
+    userId: string;
+}): Promise<PrivateDeliveryResult>;
 /** Initiate an OAuth authorization code flow for a provider and deliver the auth link to the user. */
 export declare function startOAuthFlow(provider: string, input: OAuthFlowInput): Promise<{
     ok: false;

package/dist/chat/pi/conversation-events.d.ts

@@ -5,7 +5,7 @@
  * stored messages into the active Pi context.
  */
 import type { ModelProfile } from "@/chat/model-profile";
-import type { ConversationEvent } from "@/chat/conversations/history";
+import type { ConversationEvent, AgentHistoryItem } from "@/chat/conversations/history";
 import { type PiMessage } from "@/chat/pi/messages";
 import { type ConversationMessageProvenance } from "@/chat/conversations/provenance";
 /** Pi context projected from one Junior model-history version. */
@@ -19,10 +19,14 @@ export interface PiConversationProjection {
 export interface PiConversationEventProjection extends PiConversationProjection {
     seqs: number[];
 }
+/** Translate one Pi message into Junior's native durable history item. */
+export declare function historyItemFromPiMessage(message: PiMessage, provenance: ConversationMessageProvenance): AgentHistoryItem;
+/** Translate one Junior-native history item into the Pi message it represents. */
+export declare function piMessageFromHistoryItem(data: AgentHistoryItem): PiMessage;
 /**
  * Project ordered Junior events into Pi context.
  *
- * Compaction and handoff start with replacement history. Later agent-step
+ * Compaction and handoff start with replacement history. Later native history
  * events append after it.
  *
  * Host-only events are filtered, completed authorization becomes a synthetic

package/dist/chat/plugins/annotations.d.ts

@@ -0,0 +1,8 @@
+import { type ConversationAnnotation, type PluginAnnotations } from "@sentry/junior-plugin-api";
+import type { JuniorDatabase } from "@/db/db";
+export declare function createPluginAnnotations(args: {
+    conversationId: string;
+    db: JuniorDatabase;
+    plugin: string;
+}): PluginAnnotations;
+export declare function listConversationAnnotations(db: JuniorDatabase, conversationId: string): Promise<ConversationAnnotation[]>;

package/dist/chat/plugins/registry.d.ts

@@ -1,10 +1,8 @@
-import type { CapabilityProviderDefinition } from "@/chat/capabilities/catalog";
 import type { CredentialBroker } from "@/chat/credentials/broker";
 import { type InstalledPluginPackageContent } from "./package-discovery";
 import type { InlinePluginManifestDefinition, PluginBrokerDeps, PluginCatalogConfig, PluginDefinition, OAuthProviderConfig, PluginRuntimeDependency, PluginRuntimePostinstallCommand } from "./types";
 export interface PluginCatalogRuntime {
     createBroker(provider: string, deps: PluginBrokerDeps): CredentialBroker;
-    getCapabilityProviders(): CapabilityProviderDefinition[];
     getDefinition(provider: string): PluginDefinition | undefined;
     getDisplayName(provider: string): string | undefined;
     getForSkillPath(skillPath: string): PluginDefinition | undefined;
@@ -20,7 +18,6 @@ export interface PluginCatalogRuntime {
     getRuntimePostinstall(): PluginRuntimePostinstallCommand[];
     getSignature(): string;
     getSkillRoots(): string[];
-    isCapability(capability: string): boolean;
     isConfigKey(key: string): boolean;
     isProvider(provider: string): boolean;
     parseConfiguredInlineManifest(manifest: InlinePluginManifestDefinition["manifest"], dir: string): PluginDefinition["manifest"];

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

@@ -63,7 +63,6 @@ export interface PluginManifest {
     name: string;
     displayName: string;
     description: string;
-    capabilities: string[];
     configKeys: string[];
     domains?: string[];
     apiHeaders?: Record<string, string>;
@@ -109,7 +108,6 @@ type PluginCredentialConfig = PluginCredentialConfigBase & {
 export interface PluginManifestConfig {
     displayName?: string;
     description?: string;
-    capabilities?: string[];
     configKeys?: string[];
     domains?: string[] | null;
     apiHeaders?: Record<string, string | null> | null;

package/dist/chat/runtime/agent-continue-runner.d.ts

@@ -1,9 +1,13 @@
 import { resumeSlackTurn } from "@/chat/runtime/slack-resume";
 import { type AgentContinueRequest } from "@/chat/services/agent-continue";
 import type { AgentRunner } from "@/chat/runtime/agent-runner";
+import type { AgentRunRouting } from "@/chat/agent/request";
 /** Runtime ports for agent continuation scheduling. */
 export interface AgentContinueRunnerOptions {
     agentRunner: AgentRunner;
+    /** Exact persisted input ids accepted for a non-interactive continuation. */
+    inputMessageIds?: readonly string[];
+    routingContext?: Pick<AgentRunRouting, "actor" | "credentialContext" | "destinationVisibility" | "dispatch" | "surface">;
     resumeTurn?: typeof resumeSlackTurn;
     scheduleAgentContinue?: (request: AgentContinueRequest) => Promise<void>;
     scheduleSessionCompletedPluginTasks?: (params: {

package/dist/chat/runtime/reply-executor.d.ts

@@ -17,6 +17,7 @@ import type { ContextCompactor } from "@/chat/services/context-compaction";
 import { lookupSlackUser } from "@/chat/slack/user";
 import type { AgentContinueRequest } from "@/chat/services/agent-continue";
 import type { ConversationTurnLifecycle } from "@/chat/conversations/turn-lifecycle";
+import type { DispatchTurnContext, DispatchTurnResult } from "@/chat/agent-dispatch/types";
 export interface ReplyExecutorServices {
     agentRunner: AgentRunner;
     contextCompactor: ContextCompactor;
@@ -51,7 +52,7 @@ interface ReplyExecutorDeps {
     prepareTurnState: (args: PrepareTurnStateInput) => Promise<PreparedTurnState>;
     services: ReplyExecutorServices;
 }
-/** Build the Slack reply handler that prepares state, runs Pi, and delivers replies. */
+/** Build the shared reply handler that prepares, advances, and commits a turn. */
 export declare function createReplyToThread(deps: ReplyExecutorDeps): (thread: Thread, message: Message, options: {
     beforeFirstResponsePost?: () => Promise<void>;
     destination: Destination;
@@ -59,9 +60,13 @@ export declare function createReplyToThread(deps: ReplyExecutorDeps): (thread: T
     ack?: () => Promise<void>;
     onToolInvocation?: (invocation: TurnToolInvocation) => void;
     onTurnCompleted?: () => Promise<void>;
+    onTurnDeliveryAccepted?: (messageId?: string) => void;
+    onTurnOutcome?: (result: DispatchTurnResult) => void;
     onTurnStatePersisted?: () => Promise<void>;
     preparedState?: PreparedTurnState;
     queuedMessages?: QueuedTurnMessage[];
+    execution?: DispatchTurnContext;
+    skipBackfill?: boolean;
     drainSteeringMessages?: (accept: (messages: QueuedTurnMessage[]) => Promise<void>, context?: {
         conversationContext?: string;
     }) => Promise<QueuedTurnMessage[]>;

package/dist/chat/runtime/slack-resume.d.ts

@@ -12,8 +12,10 @@ interface ResumeSlackTurnArgs {
     messageText: string;
     conversationId: string;
     turnId: string;
+    /** Active durable execution slice being resumed. */
+    sliceId?: number;
     channelId: string;
-    threadTs: string;
+    threadTs?: string;
     messageTs?: SlackMessageTs;
     replyContext?: ResumeReplyContext;
     lockKey?: string;
@@ -41,6 +43,8 @@ type ResumeReplyContext = Omit<AgentRunRequest, "conversationId" | "turnId" | "r
 };
 interface ResumePreparedTurn {
     messageText: string;
+    /** Active durable execution slice being resumed. */
+    sliceId?: number;
     messageTs?: SlackMessageTs;
     inputMessageIds?: string[];
     initialStatus?: AssistantStatusSpec;

package/dist/chat/runtime/turn-input.d.ts

@@ -1,4 +1,5 @@
 import type { Message, Thread } from "chat";
+import type { ChannelConfigurationService } from "@/chat/configuration/types";
 export interface TurnContext {
     channelId?: string;
     actorId?: string;
@@ -18,10 +19,12 @@ export interface QueuedTurnMessage extends TurnMessageText {
     message: Message;
 }
 export interface PrepareTurnStateInput {
+    channelConfiguration?: ChannelConfigurationService;
     context: TurnContext;
     explicitMention: boolean;
     message: Message;
     queuedMessages?: QueuedTurnMessage[];
+    skipBackfill?: boolean;
     text: TurnMessageText;
     thread: Thread;
 }

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

@@ -113,6 +113,52 @@ export declare const sandboxEgressPermissionDeniedSignalSchema: z.ZodObject<{
     upstreamPath: z.ZodString;
     createdAtMs: z.ZodNumber;
 }, z.core.$strict>;
+export declare const sandboxEgressSignalsResponseSchema: z.ZodObject<{
+    auth_required: z.ZodOptional<z.ZodObject<{
+        authorization: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodString;
+            scope: z.ZodOptional<z.ZodString>;
+            type: z.ZodLiteral<"oauth">;
+        }, z.core.$strict>>;
+        grant: z.ZodObject<{
+            access: z.ZodUnion<readonly [z.ZodLiteral<"read">, z.ZodLiteral<"write">]>;
+            leaseScope: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            reason: z.ZodOptional<z.ZodString>;
+            requirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>;
+        kind: z.ZodDefault<z.ZodEnum<{
+            unavailable: "unavailable";
+            auth_required: "auth_required";
+        }>>;
+        provider: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+        createdAtMs: z.ZodNumber;
+    }, z.core.$strict>>;
+    permission_denied: z.ZodOptional<z.ZodObject<{
+        account: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        acceptedPermissions: z.ZodOptional<z.ZodString>;
+        grant: z.ZodObject<{
+            access: z.ZodUnion<readonly [z.ZodLiteral<"read">, z.ZodLiteral<"write">]>;
+            leaseScope: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            reason: z.ZodOptional<z.ZodString>;
+            requirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>;
+        message: z.ZodString;
+        provider: z.ZodString;
+        source: z.ZodLiteral<"upstream">;
+        sso: z.ZodOptional<z.ZodString>;
+        status: z.ZodNumber;
+        upstreamHost: z.ZodString;
+        upstreamPath: z.ZodString;
+        createdAtMs: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
 export type SandboxEgressCredentialContext = z.output<typeof sandboxEgressCredentialContextSchema>;
 export type SandboxEgressGrant = z.output<typeof sandboxEgressGrantSchema>;
 export type SandboxEgressCredentialLease = z.output<typeof sandboxEgressCredentialLeaseSchema>;

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

@@ -0,0 +1,9 @@
+import type { SandboxEgressAuthRequiredSignal, SandboxEgressPermissionDeniedSignal } from "@/chat/sandbox/egress/schemas";
+/** Authenticated transport for signal state owned by another Junior process. */
+export interface SandboxEgressSignalTransport {
+    clear: (credentialToken: string) => Promise<void>;
+    consume: (credentialToken: string) => Promise<{
+        authRequired?: SandboxEgressAuthRequiredSignal;
+        permissionDenied?: SandboxEgressPermissionDeniedSignal;
+    }>;
+}

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

@@ -1,8 +1,9 @@
 import { type LogContext } from "@/chat/logging";
+import type { SandboxEgressSignalTransport } from "@/chat/sandbox/egress/signals";
 import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
 import type { CredentialContext } from "@/chat/credentials/context";
 import type { SandboxRef } from "@/chat/sandbox/ref";
-import type { SandboxWorkspace } from "@/chat/sandbox/workspace";
+import { type SandboxWorkspace } from "@/chat/sandbox/workspace";
 import type { SkillMetadata } from "@/chat/skills";
 export interface SandboxToolCall {
     toolName: string;
@@ -17,6 +18,7 @@ export interface SandboxAccess {
     readonly tools: SandboxTools;
     readonly workspace: SandboxWorkspace;
     sandboxRef(): SandboxRef | undefined;
+    close(): void;
 }
 export interface SandboxOptions {
     sandboxRef?: SandboxRef;
@@ -26,6 +28,7 @@ export interface SandboxOptions {
     traceContext?: LogContext;
     tracePropagation?: SandboxEgressTracePropagationConfig;
     credentialEgress?: CredentialContext;
+    egressSignals?: SandboxEgressSignalTransport;
     prepare?: (workspace: SandboxWorkspace) => void | Promise<void>;
     onSandboxRefChanged?: (sandboxRef: SandboxRef) => void | Promise<void>;
 }

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

@@ -19,24 +19,15 @@ interface SandboxToolExecutors {
         aborted?: boolean;
         timedOut?: boolean;
     }>;
-    readFile: (input: {
-        path: string;
-    }) => Promise<{
-        content: string;
-    }>;
-    writeFile: (input: {
-        path: string;
-        content: string;
-    }) => Promise<{
-        success: boolean;
-    }>;
     fs: SandboxFileSystem;
+    runCommand: SandboxSession["runCommand"];
 }
 interface SandboxRuntime {
     sandboxRef(): SandboxRef | undefined;
     acquire(): Promise<SandboxSession>;
     tools(): Promise<SandboxToolExecutors>;
     refreshNetworkPolicy(traceHeaders?: TracePropagationHeaders): Promise<void>;
+    close(): void;
 }
 interface SandboxRuntimeOptions {
     sandboxRef?: SandboxRef;

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

@@ -18,13 +18,21 @@ export interface SandboxFileStat {
 export interface SandboxFileSystem {
     readFile(filePath: string, options: {
         encoding: BufferEncoding;
+        signal?: AbortSignal;
     }): Promise<string>;
     writeFile(filePath: string, content: string, options?: {
         encoding?: BufferEncoding;
+        signal?: AbortSignal;
     }): Promise<void>;
-    readdir(filePath: string): Promise<string[]>;
-    stat(filePath: string): Promise<SandboxFileStat>;
+    readdir(filePath: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<string[]>;
+    stat(filePath: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<SandboxFileStat>;
 }
+/** Bind one tool call's cancellation to every sandbox filesystem operation. */
+export declare function bindSandboxFileSystem(fs: SandboxFileSystem, signal?: AbortSignal): SandboxFileSystem;
 export interface SandboxWorkspace {
     readFileToBuffer(input: {
         cwd?: string;

package/dist/chat/sentry-payload-filter.d.ts

@@ -3,12 +3,12 @@ type SentryErrorEvent = Parameters<NonNullable<Sentry.NodeOptions["beforeSend"]>
 type SentryTransactionEvent = Parameters<NonNullable<Sentry.NodeOptions["beforeSendTransaction"]>>[0];
 type SentrySpan = Parameters<Parameters<typeof Sentry.withStreamedSpan>[0]>[0];
 type SentryLog = Parameters<NonNullable<Sentry.NodeOptions["beforeSendLog"]>>[0];
-/** Remove raw private conversation payloads from Sentry error events. */
+/** Remove private conversation payloads and boundary secrets from error events. */
 export declare function scrubPrivateSentryEvent(event: SentryErrorEvent): SentryErrorEvent | null;
-/** Remove raw private conversation payloads from Sentry transaction events. */
+/** Remove private conversation payloads and boundary secrets from transactions. */
 export declare function scrubPrivateSentryTransaction(event: SentryTransactionEvent): SentryTransactionEvent | null;
-/** Remove raw private conversation payloads from streamed Sentry spans. */
+/** Remove private conversation payloads and boundary secrets from streamed spans. */
 export declare function scrubPrivateSentrySpan(span: SentrySpan): SentrySpan;
-/** Remove raw private conversation payloads from Sentry structured logs. */
+/** Remove private conversation payloads and boundary secrets from structured logs. */
 export declare function scrubPrivateSentryLog(log: SentryLog): SentryLog | null;
 export {};

package/dist/chat/services/mcp-auth-orchestration.d.ts

@@ -2,12 +2,13 @@
  * MCP authorization pause orchestration.
  *
  * This module turns an MCP client auth challenge into Junior's paused-run
- * model: create provider auth state, deliver or reuse a private Slack link,
- * record pending auth, and abort the agent so the OAuth callback can resume the
- * same session.
+ * model: create provider auth state, privately present or reuse its link,
+ * record pending auth, and abort the agent so the OAuth callback can resume
+ * the same session.
  */
 import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
 import type { Destination, Source } from "@sentry/junior-plugin-api";
+import { type OAuthAuthorization } from "@/chat/oauth-authorization";
 import { AuthorizationPauseError, type AuthorizationFlowMode } from "@/chat/services/auth-pause";
 import type { ThreadArtifactsState } from "@/chat/state/artifacts";
 import type { ConversationPendingAuthState } from "@/chat/state/conversation";
@@ -32,6 +33,7 @@ export interface McpAuthOrchestrationInput {
     getMergedArtifactState: () => ThreadArtifactsState;
     recordPendingAuth?: (pendingAuth: ConversationPendingAuthState | undefined) => void | Promise<void>;
     authorizationFlowMode?: AuthorizationFlowMode;
+    authorization?: OAuthAuthorization;
 }
 export interface McpAuthOrchestration {
     authProviderFactory: (plugin: PluginDefinition) => Promise<OAuthClientProvider | undefined>;

package/dist/chat/services/plugin-auth-orchestration.d.ts

@@ -14,6 +14,7 @@ import type { Destination, Source } from "@sentry/junior-plugin-api";
 import type { UserTokenStore } from "@/chat/credentials/user-token-store";
 import { AuthorizationPauseError, type AuthorizationFlowMode } from "@/chat/services/auth-pause";
 import type { ConversationPendingAuthState } from "@/chat/state/conversation";
+import { type OAuthAuthorization } from "@/chat/oauth-authorization";
 export declare class PluginAuthorizationPauseError extends AuthorizationPauseError {
     constructor(provider: string, providerDisplayName: string, disposition: "link_already_sent" | "link_sent", requestText?: string);
 }
@@ -35,6 +36,7 @@ export interface PluginAuthOrchestrationInput {
     recordPendingAuth?: (pendingAuth: ConversationPendingAuthState) => void | Promise<void>;
     authorizationFlowMode?: AuthorizationFlowMode;
     userTokenStore?: UserTokenStore;
+    authorization?: OAuthAuthorization;
 }
 export interface PluginAuthOrchestration {
     /**

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

@@ -1,4 +1,4 @@
-import { type AgentTurnSessionRecord, type AgentTurnSurface } from "@/chat/state/turn-session";
+import { type AgentDispatchOutcome, type AgentTurnSessionRecord, type AgentTurnSurface } from "@/chat/state/turn-session";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
 import type { Destination, Actor, Source } from "@sentry/junior-plugin-api";
 import type { PiMessage } from "@/chat/pi/messages";
@@ -27,6 +27,7 @@ export declare function persistRunningSessionRecord(args: {
     channelName?: string;
     conversationId: string;
     destination?: Destination;
+    dispatchId?: string;
     source?: Source;
     sessionId: string;
     sliceId: number;
@@ -56,8 +57,13 @@ export declare function persistCompletedSessionRecord(args: {
     currentDurationMs?: number;
     currentUsage?: AgentTurnUsage;
     destination?: Destination;
+    dispatchId?: string;
+    dispatchOutcome?: AgentDispatchOutcome;
+    errorMessage?: string;
     /** Source-confirmed destination visibility from the current event's signal. */
     destinationVisibility?: ConversationPrivacy;
+    /** Provider-owned identifier returned after visible delivery is accepted. */
+    resultMessageId?: string;
     source?: Source;
     sessionId: string;
     /** Defaults to the latest stored slice when the deliverer does not know it. */
@@ -76,12 +82,16 @@ export declare function completeDeliveredTurn(args: {
     conversationId: string;
     destination: Destination;
     destinationVisibility?: ConversationPrivacy;
+    dispatchId?: string;
+    dispatchOutcome?: AgentDispatchOutcome;
+    errorMessage?: string;
     durationMs?: number;
     loadedSkillNames?: string[];
     messages: PiMessage[];
     modelId: string;
     actor?: Actor;
     reasoningLevel?: string;
+    resultMessageId?: string;
     sessionId: string;
     sliceId: number;
     source: Source;
@@ -101,6 +111,7 @@ export declare function persistAuthPauseSessionRecord(args: {
     currentDurationMs?: number;
     currentUsage?: AgentTurnUsage;
     destination?: Destination;
+    dispatchId?: string;
     source?: Source;
     messages: PiMessage[];
     loadedSkillNames?: string[];
@@ -119,6 +130,7 @@ interface ContinuationRecordInput {
     currentDurationMs?: number;
     currentUsage?: AgentTurnUsage;
     destination?: Destination;
+    dispatchId?: string;
     source?: Source;
     messages: PiMessage[];
     loadedSkillNames?: string[];
@@ -144,6 +156,7 @@ export declare function persistYieldSessionRecord(args: {
     currentDurationMs?: number;
     currentUsage?: AgentTurnUsage;
     destination?: Destination;
+    dispatchId?: string;
     source?: Source;
     messages: PiMessage[];
     loadedSkillNames?: string[];

package/dist/chat/slack/dispatch-turn.d.ts

@@ -0,0 +1,25 @@
+import { Message, ThreadImpl } from "chat";
+import type { SlackAdapter } from "@chat-adapter/slack";
+import type { DispatchTurnContext, DispatchTurnResult } from "@/chat/agent-dispatch/types";
+import type { DispatchRecord } from "@/chat/agent-dispatch/types";
+interface DispatchReplyToThread {
+    (thread: ThreadImpl, message: Message, options: {
+        ack?: () => Promise<void>;
+        destination: DispatchRecord["destination"];
+        execution: DispatchTurnContext;
+        onTurnDeliveryAccepted?: (messageId?: string) => void;
+        onTurnOutcome?: (result: DispatchTurnResult) => void;
+        shouldYield?: () => boolean;
+        skipBackfill?: boolean;
+    }): Promise<void>;
+}
+/** Build the Slack provider adapter for plugin-dispatched conversation turns. */
+export declare function createSlackDispatchTurnRunner(options: {
+    getChannelConfiguration: (channelId: string) => DispatchTurnContext["channelConfiguration"];
+    getSlackAdapter: () => SlackAdapter;
+    replyToThread: DispatchReplyToThread;
+}): (dispatch: DispatchRecord, hooks: {
+    ack: () => Promise<void>;
+    shouldYield?: () => boolean;
+}) => Promise<DispatchTurnResult>;
+export {};

package/dist/chat/slack/message-control.d.ts

@@ -0,0 +1,2 @@
+/** Remove the explicit Slack steering marker before building agent input. */
+export declare function stripLeadingSteeringOverride(text: string): string;

package/dist/chat/slack/oauth-authorization-message.d.ts

@@ -0,0 +1,3 @@
+import type { OAuthAuthorizationRequest } from "@/chat/oauth-authorization";
+/** Format the private OAuth authorization prompt for Slack delivery. */
+export declare function formatOAuthAuthorizationMessage(args: OAuthAuthorizationRequest): string;

package/dist/chat/state/turn-session.d.ts

@@ -18,6 +18,7 @@ import type { ConversationStore } from "@/chat/conversations/store";
 export type AgentTurnSessionStatus = "running" | "awaiting_resume" | "completed" | "failed" | "abandoned";
 export type AgentTurnSurface = "slack" | "api" | "scheduler" | "internal";
 export type AgentTurnResumeReason = "timeout" | "auth" | "yield" | "retry";
+export type AgentDispatchOutcome = "blocked" | "completed" | "failed";
 export interface AgentTurnSessionRecord {
     channelName?: string;
     version: number;
@@ -25,6 +26,10 @@ export interface AgentTurnSessionRecord {
     cumulativeDurationMs: number;
     cumulativeUsage?: AgentTurnUsage;
     destination?: Destination;
+    dispatchId?: string;
+    dispatchOutcome?: AgentDispatchOutcome;
+    /** Provider-owned identifier returned after visible delivery is accepted. */
+    resultMessageId?: string;
     source?: Source;
     errorMessage?: string;
     lastProgressAtMs: number;
@@ -66,6 +71,9 @@ export declare function upsertAgentTurnSessionRecord(args: {
     cumulativeDurationMs?: number;
     cumulativeUsage?: AgentTurnUsage;
     destination?: Destination;
+    dispatchId?: string;
+    dispatchOutcome?: AgentDispatchOutcome;
+    resultMessageId?: string;
     /** Source-confirmed destination visibility from the current event's signal. */
     destinationVisibility?: ConversationPrivacy;
     source?: Source;
@@ -97,6 +105,9 @@ export declare function recordAgentTurnSessionSummary(args: {
     cumulativeDurationMs?: number;
     cumulativeUsage?: AgentTurnUsage;
     destination?: Destination;
+    dispatchId?: string;
+    dispatchOutcome?: AgentDispatchOutcome;
+    resultMessageId?: string;
     /**
      * Source-confirmed destination visibility from the current event's signal
      * (Slack `channel_type`). Leave unset when no live signal exists so an

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

@@ -7,6 +7,7 @@ import type { InboundMessage } from "@/chat/task-execution/store";
 import type { ConversationWorkerContext, ConversationWorkerResult } from "@/chat/task-execution/worker";
 import { type SlackInstallationContext } from "@/chat/slack/adapter-context";
 import { type SlackActorProfile } from "@/chat/actor";
+import { type CrossActorMidRunMode } from "@/chat/config";
 declare const slackConversationRouteSchema: z.ZodEnum<{
     mention: "mention";
     subscribed: "subscribed";
@@ -270,6 +271,7 @@ interface SlackResourceEventInboundInput {
     text: string;
 }
 export interface CreateSlackConversationWorkerOptions {
+    crossActorMidRunMode?: CrossActorMidRunMode;
     getSlackAdapter: () => SlackAdapter;
     lookupSlackUser?: (teamId: string, userId: string) => Promise<SlackActorProfile | null | undefined>;
     resumeAwaitingContinuation: (conversationId: string, options: {

package/dist/chat/tool-support/text-range-result.d.ts

@@ -13,8 +13,11 @@ interface TextRangeResult {
             path: string;
             start_line: number;
             total_lines: number;
+            truncation_reasons?: string[];
         };
         truncated: boolean;
+        character_limit_reached?: number;
+        line_truncated?: boolean;
         continuation?: {
             arguments: {
                 offset: number;