@sentry/junior 0.106.0 → 0.107.1

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

@@ -1,6 +1,7 @@
-import type { AgentRunRequest } from "@/chat/agent/request";
+import { type AgentRunRequest } from "@/chat/agent/request";
 import type { AgentRunResult } from "@/chat/services/turn-result";
 import type { AgentRunner } from "@/chat/runtime/agent-runner";
+import { type ConversationTurnLifecycle } from "@/chat/conversations/turn-lifecycle";
 import { type AssistantStatusSpec } from "@/chat/slack/assistant-thread/status";
 import type { SlackMessageTs } from "@/chat/slack/timestamp";
 /** Error raised when another worker already owns the resume lock. */
@@ -9,6 +10,8 @@ export declare class ResumeTurnBusyError extends Error {
 }
 interface ResumeSlackTurnArgs {
     messageText: string;
+    conversationId: string;
+    turnId: string;
     channelId: string;
     threadTs: string;
     messageTs?: SlackMessageTs;
@@ -17,6 +20,8 @@ interface ResumeSlackTurnArgs {
     initialText?: string;
     initialStatus?: AssistantStatusSpec;
     agentRunner: AgentRunner;
+    inputMessageIds?: string[];
+    turnLifecycle?: ConversationTurnLifecycle;
     scheduleSessionCompletedPluginTasks?: (params: {
         conversationId: string;
         sessionId: string;
@@ -26,44 +31,34 @@ interface ResumeSlackTurnArgs {
     onAuthPause?: (pause: {
         providerDisplayName: string;
     }) => Promise<void>;
-    onTimeoutPause?: (resume: {
-        resumeVersion: number;
-    }) => Promise<void>;
+    onSuspend?: (resumeVersion: number) => Promise<void>;
     onPostDeliveryCommitFailure?: (error: unknown) => Promise<void>;
-    beforeStart?: () => Promise<Partial<ResumeSlackTurnArgs> | false | void>;
+    beforeStart?: () => Promise<ResumePreparedTurn | false | void>;
     replyTimeoutMs?: number;
 }
-type ResumeReplyContext = Omit<AgentRunRequest, "input"> & {
+type ResumeReplyContext = Omit<AgentRunRequest, "conversationId" | "turnId" | "runId" | "input" | "delivery"> & {
     input?: Omit<AgentRunRequest["input"], "messageText">;
 };
-/**
- * Resume a paused Slack turn under the normal thread lock.
- *
- * Started resumes own their terminal side effects: final delivery, pause
- * persistence, or failure response. Returns false only when `beforeStart`
- * proves the resume is stale before generation begins.
- */
-export declare function resumeSlackTurn(args: ResumeSlackTurnArgs): Promise<boolean>;
-/** Resume an OAuth-paused Slack request through the shared resume runner. */
-export declare function resumeAuthorizedRequest(args: {
+interface ResumePreparedTurn {
     messageText: string;
-    channelId: string;
-    threadTs: string;
     messageTs?: SlackMessageTs;
-    connectedText: string;
-    replyContext?: ResumeReplyContext;
-    lockKey?: string;
-    agentRunner: AgentRunner;
+    inputMessageIds?: string[];
+    initialStatus?: AssistantStatusSpec;
+    replyContext: ResumeReplyContext;
     onSuccess?: (reply: AgentRunResult) => Promise<void>;
     onFailure?: (error: unknown) => Promise<void>;
     onAuthPause?: (pause: {
         providerDisplayName: string;
     }) => Promise<void>;
-    onTimeoutPause?: (resume: {
-        resumeVersion: number;
-    }) => Promise<void>;
+    onSuspend?: (resumeVersion: number) => Promise<void>;
     onPostDeliveryCommitFailure?: (error: unknown) => Promise<void>;
-    beforeStart?: () => Promise<Partial<ResumeSlackTurnArgs> | false | void>;
-    replyTimeoutMs?: number;
-}): Promise<void>;
+}
+/**
+ * Resume a paused Slack turn under the normal thread lock.
+ *
+ * Started resumes own their completion side effects: assistant-message
+ * delivery, pause persistence, or failure response. Returns false only when
+ * `beforeStart` proves the resume is stale before generation begins.
+ */
+export declare function resumeSlackTurn(args: ResumeSlackTurnArgs): Promise<boolean>;
 export {};

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

@@ -10,6 +10,7 @@ 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?: {
@@ -52,6 +53,7 @@ export interface SlackTurnRuntimeDependencies<TPreparedState> {
         threadId: string;
         threadTs: string;
     }) => Promise<void>;
+    failConversationTurn: (input: FailConversationTurnInput) => Promise<void>;
     refreshAssistantThreadContext: (event: {
         channelId: string;
         sourceChannelId?: string;

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

@@ -1,5 +1,18 @@
 import type { ThreadConversationState } from "@/chat/state/conversation";
+import type { ConversationTurnFailureCode } from "@/chat/conversations/history";
 export { buildDeterministicTurnId } from "@/chat/state/turn-id";
+/** Classified Slack turn failure carrying the owning Sentry capture outward. */
+export declare class ConversationTurnBoundaryError extends Error {
+    readonly eventId?: string;
+    readonly failureCode: ConversationTurnFailureCode;
+    constructor(args: {
+        cause: unknown;
+        eventId?: string;
+        failureCode: ConversationTurnFailureCode;
+    });
+}
+/** Return a classified Slack boundary failure without erasing its cause. */
+export declare function getConversationTurnBoundaryError(error: unknown): ConversationTurnBoundaryError | undefined;
 /**
  * Queue-worker yield routing: respond.ts returns a suspended AgentRunOutcome
  * and the Slack executor raises this at the worker boundary so the lease owner
@@ -42,7 +55,7 @@ export declare function markTurnClosed(args: {
     updateConversationStats: (conversation: ThreadConversationState) => void;
 }): void;
 /**
- * Mark a turn as completed after final reply delivery succeeds.
+ * Mark a turn as completed after its assistant output has been handled.
  */
 export declare function markTurnCompleted(args: {
     conversation: ThreadConversationState;

package/dist/chat/services/context-compaction-marker.d.ts

@@ -1,6 +1,5 @@
 import type { PiMessage } from "@/chat/pi/messages";
 export declare const COMPACTION_SUMMARY_PREFIX = "Context compaction summary for future Junior turns:";
-export declare const LEGACY_COMPACTION_SUMMARY_PREFIX = "Context handoff summary for future Junior turns:";
 export declare const MODEL_HANDOFF_SUMMARY_PREFIX = "Model handoff checkpoint. Continue the outstanding request now using this summary as the complete prior context:";
 /** Return whether text is one of Junior's durable compacted-context markers. */
 export declare function isCompactionSummaryText(text: string): boolean;

package/dist/chat/services/context-compaction.d.ts

@@ -34,6 +34,7 @@ interface HandoffContextArgs {
     piMessages: PiMessage[];
     runtimeContext: PiMessage[];
     signal?: AbortSignal;
+    triggeringToolCallId?: string;
     target: {
         modelId: string;
         modelProfile: ModelProfile;

package/dist/chat/services/conversation-memory.d.ts

@@ -17,6 +17,15 @@ export declare function generateConversationId(prefix: "assistant" | "backfill"
 export declare function normalizeConversationText(text: string): string;
 export declare function updateConversationStats(conversation: ThreadConversationState): void;
 export declare function upsertConversationMessage(conversation: ThreadConversationState, message: ConversationMessage): string;
+/** Record one assistant message after its destination accepts it. */
+export declare function recordDeliveredAssistantMessage(args: {
+    conversation: ThreadConversationState;
+    sessionId: string;
+    text: string;
+    userMessageId?: string;
+}): string;
+/** Return whether a turn already has a destination-accepted assistant reply. */
+export declare function turnHasReply(conversation: ThreadConversationState, turnId: string): boolean;
 export declare function markConversationMessage(conversation: ThreadConversationState, messageId: string | undefined, patch: Partial<NonNullable<ConversationMessage["meta"]>>): void;
 /**
  * Render thread history as structured XML. Each compaction and message is

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

@@ -3,7 +3,7 @@
  *
  * This module detects plugin credential failures from the sandbox egress layer
  * and maps them onto the same paused-run contract used by MCP auth. It owns
- * provider attribution, private-link delivery/reuse, session-log recording,
+ * provider attribution, private-link delivery/reuse, event-log recording,
  * and credential cleanup.
  *
  * Auth failures are detected exclusively through the structured `auth_required`
@@ -11,7 +11,6 @@
  * stdout patterns, or exit codes.
  */
 import type { Destination, Source } from "@sentry/junior-plugin-api";
-import type { ChannelConfigurationService } from "@/chat/configuration/types";
 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";
@@ -31,8 +30,6 @@ export interface PluginAuthOrchestrationInput {
     destination?: Destination;
     source?: Source;
     threadTs?: string;
-    userMessage: string;
-    channelConfiguration?: ChannelConfigurationService;
     pendingAuth?: ConversationPendingAuthState;
     recordPendingAuth?: (pendingAuth: ConversationPendingAuthState) => void | Promise<void>;
     authorizationFlowMode?: AuthorizationFlowMode;

package/dist/chat/services/subscribed-decision.d.ts

@@ -33,7 +33,7 @@ declare const replyDecisionSchema: z.ZodObject<{
     should_reply: z.ZodBoolean;
     should_unsubscribe: z.ZodBoolean;
     confidence: z.ZodNumber;
-    reason: z.ZodOptional<z.ZodString>;
+    reason: z.ZodString;
 }, z.core.$strict>;
 /** Fast heuristic check before the LLM classifier — skips messages directed at another party. */
 export declare function getSubscribedReplyPreflightDecision(args: {

package/dist/chat/services/turn-failure-response.d.ts

@@ -5,11 +5,18 @@ type LogException = (error: unknown, eventName: string, context?: LogContext, at
 export declare function requireTurnFailureEventId(eventId: string | undefined, eventName: string): string;
 /** Keep failed-turn Sentry captures and completion spans on the same keys. */
 export declare function getAgentTurnDiagnosticsAttributes(reply: AgentRunResult): Record<string, unknown>;
-/** Enforce one captured, event-ID-bearing failure response before delivery. */
-export declare function finalizeFailedTurnReply(args: {
+/** Sanitized failure fallback plus its optional captured event ID. */
+export interface FinalizedTurnFailure {
+    eventId?: string;
+    reply: AgentRunResult;
+}
+/** Enforce one captured failure response and return its structured correlation. */
+export declare function finalizeFailedTurnReplyWithEvent(args: {
     reply: AgentRunResult;
     logException: LogException;
     context: LogContext;
     attributes?: Record<string, unknown>;
-}): AgentRunResult;
+}): FinalizedTurnFailure;
+/** Enforce one captured, event-ID-bearing failure response before delivery. */
+export declare function finalizeFailedTurnReply(args: Parameters<typeof finalizeFailedTurnReplyWithEvent>[0]): AgentRunResult;
 export {};

package/dist/chat/services/turn-result.d.ts

@@ -1,9 +1,9 @@
 import type { LogContext } from "@/chat/logging";
 import type { PiMessage } from "@/chat/pi/messages";
-import type { TurnReasoningSelection } from "@/chat/services/turn-reasoning-level";
+import type { TurnRoute } from "@/chat/services/turn-router";
 import type { AgentTurnUsage } from "@/chat/usage";
-import type { ReplyDeliveryPlan } from "@/chat/services/reply-delivery-plan";
 import type { ThreadArtifactsState } from "@/chat/state/artifacts";
+import { extractAssistantText } from "@/chat/pi/transcript";
 export interface AgentTurnDiagnostics {
     assistantMessageCount: number;
     durationMs?: number;
@@ -11,7 +11,7 @@ export interface AgentTurnDiagnostics {
     providerError?: unknown;
     modelId: string;
     outcome: "success" | "execution_failure" | "provider_error";
-    reasoningLevel?: TurnReasoningSelection["reasoningLevel"];
+    reasoningLevel?: TurnRoute["reasoningLevel"];
     stopReason?: string;
     toolCalls: string[];
     toolErrorCount: number;
@@ -20,10 +20,9 @@ export interface AgentTurnDiagnostics {
     usedPrimaryText: boolean;
 }
 export interface AgentRunResult {
+    /** Sanitized terminal text for diagnostics and failure fallback, not success delivery. */
     text: string;
     artifactStatePatch?: Partial<ThreadArtifactsState>;
-    deliveryPlan?: ReplyDeliveryPlan;
-    deliveryMode?: "thread" | "channel_only";
     sandboxId?: string;
     sandboxDependencyProfileHash?: string;
     piMessages?: PiMessage[];
@@ -42,15 +41,11 @@ export interface TurnResultInput {
     shouldTrace: boolean;
     spanContext: LogContext;
     usage?: AgentTurnUsage;
-    reasoningSelection: TurnReasoningSelection;
-    correlation?: {
-        threadId?: string;
-        actorId?: string;
-        channelId?: string;
-        runId?: string;
-    };
+    executionProfile: TurnRoute;
     assistantUserName?: string;
     modelId: string;
 }
+/** Return destination-visible text from one completed tool-free assistant message. */
+export declare function getAssistantMessageText(message: Parameters<typeof extractAssistantText>[0]): string | undefined;
 /** Process raw agent messages into a structured AgentRunResult. */
 export declare function buildTurnResult(input: TurnResultInput): AgentRunResult;

package/dist/chat/services/{turn-reasoning-level.d.ts → turn-router.d.ts}

@@ -2,7 +2,8 @@ import type { ThinkingLevel as AgentThinkingLevel } from "@earendil-works/pi-age
 import type { ThinkingLevel as ProviderThinkingLevel } from "@earendil-works/pi-ai";
 import { z } from "zod";
 import { type TurnReasoningLevel } from "@/chat/reasoning-level";
-declare const turnExecutionProfileSchema: z.ZodObject<{
+import { type ModelProfile, type ExecutionProfileConfig } from "@/chat/model-profile";
+declare function createTurnRouteSchema(profiles: Readonly<Record<string, ExecutionProfileConfig>>): z.ZodObject<{
     reasoning_level: z.ZodEnum<{
         low: "low";
         medium: "medium";
@@ -10,21 +11,23 @@ declare const turnExecutionProfileSchema: z.ZodObject<{
         xhigh: "xhigh";
         none: "none";
     }>;
+    profile: z.ZodString;
     confidence: z.ZodPreprocess<z.ZodNumber>;
     reason: z.ZodString;
 }, z.core.$strip>;
-export interface TurnReasoningSelection {
+export interface TurnRoute {
     confidence?: number;
+    profile: ModelProfile;
     reasoningLevel: TurnReasoningLevel;
     reason: string;
 }
 /** Preserve an explicitly configured reasoning level without invoking the router. */
-export declare function configuredTurnReasoningLevel(reasoningLevel: TurnReasoningLevel, source: "agent_config" | "default"): TurnReasoningSelection;
-/** Choose the reasoning level for the upcoming assistant turn when none is configured. */
-export declare function selectTurnReasoningLevel(args: {
+export declare function configuredTurnRoute(profile: ModelProfile, reasoningLevel: TurnReasoningLevel, source: "agent_config" | "default" | "profile"): TurnRoute;
+/** Route the upcoming assistant turn to its reasoning and model profiles. */
+export declare function selectTurnRoute(args: {
     completeObject: (args: {
         modelId: string;
-        schema: typeof turnExecutionProfileSchema;
+        schema: ReturnType<typeof createTurnRouteSchema>;
         maxTokens: number;
         metadata: Record<string, string>;
         prompt: string;
@@ -44,7 +47,8 @@ export declare function selectTurnReasoningLevel(args: {
     currentTurnBlocks?: string[];
     fastModelId: string;
     messageText: string;
-}): Promise<TurnReasoningSelection>;
+    profiles: Readonly<Record<string, ExecutionProfileConfig>>;
+}): Promise<TurnRoute>;
 /** Convert a routing bucket into the Pi Agent reasoning setting for a main turn. */
-export declare function toPiReasoningLevel(level: TurnReasoningSelection["reasoningLevel"]): AgentThinkingLevel | "off";
+export declare function toPiReasoningLevel(level: TurnRoute["reasoningLevel"]): AgentThinkingLevel | "off";
 export {};

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

@@ -2,14 +2,13 @@ import { type AgentTurnSessionRecord, type AgentTurnSurface } from "@/chat/state
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
 import type { Destination, Actor, Source } from "@sentry/junior-plugin-api";
 import type { PiMessage } from "@/chat/pi/messages";
-import type { PiMessageProvenance } from "@/chat/state/session-log";
+import type { ConversationMessageProvenance } from "@/chat/conversations/provenance";
 import { type AgentTurnUsage } from "@/chat/usage";
 export interface TurnSessionContext {
-    conversationId?: string;
-    sessionId?: string;
+    conversationId: string;
+    sessionId: string;
 }
 export interface TurnSessionState {
-    canUseTurnSession: boolean;
     resumedFromSessionRecord: boolean;
     currentSliceId: number;
     existingSessionRecord?: AgentTurnSessionRecord;
@@ -33,7 +32,7 @@ export declare function persistRunningSessionRecord(args: {
     sliceId: number;
     messages: PiMessage[];
     /** Provenance for trailing newly committed messages, such as steering. */
-    trailingMessageProvenance?: PiMessageProvenance[];
+    trailingMessageProvenance?: ConversationMessageProvenance[];
     loadedSkillNames?: string[];
     logContext: SessionRecordLogContext;
     modelId: string;
@@ -43,13 +42,13 @@ export declare function persistRunningSessionRecord(args: {
     turnStartMessageIndex?: number;
 }): Promise<boolean>;
 /**
- * Commit the delivered final reply as the terminal completed session record.
+ * Commit a run after assistant output handling has settled.
  *
- * Generation completing is not delivery: call this only after the destination
- * accepted the visible final reply, so an undelivered assistant reply never
- * becomes durable conversation history or a terminal completed state. The
- * write is retried because the reply is already user-visible, then any remaining
- * failure surfaces to the post-delivery boundary for one authoritative error.
+ * Generation completing is not durable completion: call this only after the
+ * destination accepted each visible message or intentional silence was
+ * resolved. The write is retried because output may already be user-visible;
+ * any remaining failure surfaces to the post-output boundary for one
+ * authoritative error.
  */
 export declare function persistCompletedSessionRecord(args: {
     channelName?: string;
@@ -114,11 +113,7 @@ export declare function persistAuthPauseSessionRecord(args: {
     reasoningLevel?: string;
     surface?: AgentTurnSurface;
 }): Promise<AgentTurnSessionRecord | undefined>;
-/**
- * Persist a timeout session record at the last safe boundary. Returns the durable
- * record so callers can distinguish scheduled continuations from terminal caps.
- */
-export declare function persistTimeoutSessionRecord(args: {
+interface ContinuationRecordInput {
     channelName?: string;
     conversationId: string;
     sessionId: string;
@@ -135,6 +130,10 @@ export declare function persistTimeoutSessionRecord(args: {
     actor?: Actor;
     reasoningLevel?: string;
     surface?: AgentTurnSurface;
+}
+/** Persist a timeout or delivery retry under the turn's shared slice limit. */
+export declare function persistContinuationSessionRecord(args: ContinuationRecordInput & {
+    resumeReason: "retry" | "timeout";
 }): Promise<AgentTurnSessionRecord | undefined>;
 /**
  * Persist a cooperative-yield boundary without advancing timeout slice counts.

package/dist/chat/slack/adapter.d.ts

@@ -3,7 +3,7 @@ import { type SlackAdapter, type SlackAdapterConfig } from "@chat-adapter/slack"
  * Create the repository's Slack adapter.
  *
  * Junior used to patch private Slack adapter internals to alter native stream
- * buffering. Visible reply delivery now relies on finalized thread posts plus
- * assistant status updates, so we keep the adapter on the documented surface.
+ * buffering. Visible reply delivery now relies on completed assistant-message
+ * thread posts plus status updates, so we keep the documented surface.
  */
 export declare function createJuniorSlackAdapter(config?: SlackAdapterConfig): SlackAdapter;

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

@@ -2,5 +2,7 @@
 export declare function getSlackApiErrorCode(error: unknown): string | undefined;
 /** Convert Slack Web API error details into the repository's trace attributes. */
 export declare function getSlackErrorObservabilityAttributes(error: unknown): Record<string, string | number>;
+/** Recover transient or ambiguous Slack failures, but stop on explicit rejection. */
+export declare function isRetryableSlackPostError(error: unknown): boolean;
 /** Report whether Slack rejected assistant title updates for stable auth reasons. */
 export declare function isSlackTitlePermissionError(error: unknown): boolean;

package/dist/chat/slack/outbound.d.ts

@@ -41,7 +41,6 @@ export interface SlackUploadedFile {
 /** Upload files into a Slack conversation or thread via the shared outbound file boundary. */
 export declare function uploadFilesToConversation(input: {
     channelId: string;
-    initialComment?: string;
     threadTs?: string;
     files: Array<{
         data: Buffer;

package/dist/chat/slack/reply.d.ts

@@ -1,17 +1,11 @@
-import type { AgentRunResult } from "@/chat/services/turn-result";
 import { type SlackReplyFooter } from "@/chat/slack/footer";
 export type PlannedSlackReplyStage = "thread_reply" | "thread_reply_continuation";
 export interface PlannedSlackReplyPost {
     stage: PlannedSlackReplyStage;
     text: string;
 }
-/**
- * Plan the Slack thread posts needed to realize a completed assistant reply,
- * including chunking and interruption markers.
- */
-export declare function planSlackReplyPosts(args: {
-    reply: AgentRunResult;
-}): PlannedSlackReplyPost[];
+/** Plan the Slack posts for one completed assistant message. */
+export declare function planSlackAssistantMessagePosts(text: string): PlannedSlackReplyPost[];
 /**
  * Deliver planned Slack reply posts over raw Slack Web API calls for resume and
  * callback handlers that do not have a Chat SDK thread object.

package/dist/chat/slack/tools/channel-capabilities.d.ts

@@ -2,8 +2,8 @@
 export interface ChannelCapabilities {
     /** Can create canvases in this channel (C/G/D channels). */
     canCreateCanvas: boolean;
-    /** Can send messages into this conversation scope (C/G/D channels). */
-    canSendMessage: boolean;
+    /** Can upload files into this conversation scope (C/G/D channels). */
+    canSendFiles: boolean;
     /** Can post standalone messages to this channel (C/G channels only). */
     canPostToChannel: boolean;
     /** Can add reactions to messages (C/G/D channels). */

package/dist/chat/slack/tools/{send-message.d.ts → send-files.d.ts}

@@ -1,30 +1,32 @@
 import type { SlackToolContext } from "@/chat/slack/tools/context";
-import type { SandboxFileUpload } from "@/chat/tools/sandbox/file-uploads";
+import { type SandboxFileMaterializationInput, type SandboxFileUpload } from "@/chat/tools/sandbox/file-uploads";
 import type { ToolState } from "@/chat/tools/types";
 /** Convert a model-supplied sandbox file path into bytes safe for Slack upload. */
-export type MaterializeMessageFile = (input: {
-    path: string;
-    filename?: string;
-    mimeType?: string;
-}) => Promise<SandboxFileUpload>;
-/** Create the Slack side-effect tool for active-conversation text and file messages. */
-export declare function createSendMessageTool(context: SlackToolContext, state: ToolState, materializeFile: MaterializeMessageFile): Omit<import("../../tools/definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+export type MaterializeFile = (input: SandboxFileMaterializationInput) => Promise<SandboxFileUpload>;
+/** Create the Slack side-effect tool for active-conversation file messages. */
+export declare function createSendFilesTool(context: SlackToolContext, state: ToolState, materializeFile: MaterializeFile): Omit<import("../../tools/definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
     inputSchema: import("../../tools/definition").JsonSchemaObject;
     outputSchema: import("../../tools/definition").JsonSchemaObject;
     prepareArguments(args: unknown): {
-        text?: string | null | undefined;
-        files?: {
+        files: {
             path: string;
             filename?: string | null | undefined;
             mimeType?: string | null | undefined;
-        }[] | null | undefined;
+            bytes?: number | null | undefined;
+        }[];
     };
     execute?: ((input: unknown, options: import("../../tools/definition").ToolExecuteOptions) => {
         [x: string]: unknown;
-        ok: boolean;
-        status: "error" | "success";
-        target?: string | undefined;
-        data?: unknown;
+        ok: true;
+        status: "success";
+        target: string;
+        data: {
+            channel_id: string;
+            file_count: number;
+            thread_ts: string;
+            deduplicated?: boolean | undefined;
+            file_ids?: string[] | undefined;
+        };
         truncated?: boolean | undefined;
         continuation?: {
             arguments: Record<string, unknown>;
@@ -37,10 +39,16 @@ export declare function createSendMessageTool(context: SlackToolContext, state:
         } | undefined;
     } | Promise<{
         [x: string]: unknown;
-        ok: boolean;
-        status: "error" | "success";
-        target?: string | undefined;
-        data?: unknown;
+        ok: true;
+        status: "success";
+        target: string;
+        data: {
+            channel_id: string;
+            file_count: number;
+            thread_ts: string;
+            deduplicated?: boolean | undefined;
+            file_ids?: string[] | undefined;
+        };
         truncated?: boolean | undefined;
         continuation?: {
             arguments: Record<string, unknown>;

package/dist/chat/state/conversation.d.ts

@@ -24,7 +24,7 @@ export interface ConversationMessage {
     text: string;
 }
 export interface ConversationCompaction {
-    coveredMessageIds: string[];
+    coveredMessageCount: number;
     createdAtMs: number;
     id: string;
     summary: string;
@@ -78,9 +78,9 @@ export interface ThreadConversationState {
 export declare function coerceThreadConversationState(value: unknown): ThreadConversationState;
 /**
  * Wrap a conversation state into the storage envelope for persistence. The
- * visible transcript (`messages`) is not written to `thread-state`; it lives
- * in SQL (`ConversationMessageStore`), and Pi history lives in the SQL
- * `AgentStepStore`. Only runtime scratch is persisted here.
+ * visible transcript (`messages`) is not written to `thread-state`; visible and
+ * model history live in the SQL `ConversationEventStore`. Only runtime scratch
+ * is persisted here.
  */
 export declare function buildConversationStatePatch(conversation: ThreadConversationState): {
     conversation: Omit<ThreadConversationState, "compactions" | "messages">;

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

@@ -1,2 +1,4 @@
 /** Build a stable turn identifier from a message ID. */
 export declare function buildDeterministicTurnId(messageId: string): string;
+/** Build the stable visible assistant-message identity for one logical turn. */
+export declare function buildDeterministicAssistantMessageId(turnId: string): string;

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

@@ -0,0 +1,6 @@
+/** Storage prefix shared by turn-session records and their indexes. */
+export declare const AGENT_TURN_SESSION_PREFIX = "junior:agent_turn_session";
+/** Return the durable key for one resumable turn-session record. */
+export declare function agentTurnSessionKey(conversationId: string, sessionId: string): string;
+/** Return the index key for every turn session owned by one conversation. */
+export declare function agentTurnSessionConversationIndexKey(conversationId: string): string;

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

@@ -2,22 +2,22 @@
  * Turn session records.
  *
  * These records track one user request across auth pauses, timeout slices, and
- * completion. Full Pi messages live in the durable agent step store; this
+ * completion. Full Pi messages live in the durable conversation event store; this
  * record stores resumability metadata and a committed `seq` cursor into
- * `junior_agent_steps` so resumes can materialize the exact continuable
- * boundary without duplicating the step history.
+ * `junior_conversation_events` so resumes can materialize the exact continuable
+ * boundary without duplicating the event history.
  */
 import { type StateAdapter } from "chat";
 import { type Destination, type Source } from "@sentry/junior-plugin-api";
-import type { PiMessage } from "@/chat/pi/messages";
+import { type PiMessage } from "@/chat/pi/messages";
 import { type Actor } from "@/chat/actor";
-import { type PiMessageProvenance } from "./session-log";
+import { type ConversationMessageProvenance } from "@/chat/conversations/provenance";
 import { type AgentTurnUsage } from "@/chat/usage";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
 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";
+export type AgentTurnResumeReason = "timeout" | "auth" | "yield" | "retry";
 export interface AgentTurnSessionRecord {
     channelName?: string;
     version: number;
@@ -33,7 +33,7 @@ export interface AgentTurnSessionRecord {
     reasoningLevel?: string;
     piMessages: PiMessage[];
     /** Per-message provenance aligned one-to-one with `piMessages`. */
-    piMessageProvenance: PiMessageProvenance[];
+    piMessageProvenance: ConversationMessageProvenance[];
     /**
      * All distinct actors annotated on this run's committed instruction-authority
      * messages, in first-seen order. Persisted as an attribution handle so a
@@ -55,8 +55,10 @@ export interface AgentTurnSessionRecord {
     updatedAtMs: number;
 }
 export type AgentTurnSessionSummary = Omit<AgentTurnSessionRecord, "errorMessage" | "actors" | "piMessages" | "piMessageProvenance" | "turnStartMessageIndex">;
-/** Read a materialized turn session record for resume and history loading. */
+/** Read a turn record pinned to the history version containing its checkpoint. */
 export declare function getAgentTurnSessionRecord(conversationId: string, sessionId: string): Promise<AgentTurnSessionRecord | undefined>;
+/** Read a turn session for resume, following a newer committed replacement while unfinished. */
+export declare function getAgentTurnSessionRecordForResume(conversationId: string, sessionId: string): Promise<AgentTurnSessionRecord | undefined>;
 /** Commit stable Pi session state and advance the turn session record. */
 export declare function upsertAgentTurnSessionRecord(args: {
     channelName?: string;
@@ -77,7 +79,7 @@ export declare function upsertAgentTurnSessionRecord(args: {
     surface?: AgentTurnSurface;
     piMessages: PiMessage[];
     /** Provenance for trailing newly committed messages, such as steering. */
-    trailingMessageProvenance?: PiMessageProvenance[];
+    trailingMessageProvenance?: ConversationMessageProvenance[];
     actor?: Actor;
     actors?: Actor[];
     resumeReason?: AgentTurnResumeReason;