@sentry/junior 0.143.0 → 0.145.0

package/dist/chat/task-execution/checkpoint.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Turn checkpoint — public resume cursor for one turn.
+ *
+ * Part of conversation execution with mailbox + lease + worker.
+ * History is SQL (`commitMessages`). This module is the only external gate
+ * for turn cursor storage (`turn-cursor.ts` is internal).
+ *
+ * Public API:
+ * - `loadTurnCheckpoint({ conversationId, turnId })`
+ * - `saveTurnCheckpoint({ mode, conversationId, turnId, messages, ... })`
+ * - fail / abandon / summary helpers for terminal and recovery edges
+ */
+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 { ConversationMessageProvenance } from "@/chat/conversations/provenance";
+import { type AgentTurnUsage } from "@/chat/usage";
+import type { PluginTurnContext } from "@/chat/plugins/prompt";
+import { abandonTurnRecord, failTurnRecord, getTurnRecord, listTurnSummaries, recordTurnSummary, type AgentDispatchOutcome, type TurnPauseReason, type TurnRecord, type TurnSummary, type AgentTurnSurface } from "./turn-cursor";
+export type { AgentDispatchOutcome, TurnRecord, TurnSummary, AgentTurnSurface };
+export { abandonTurnRecord, failTurnRecord, getTurnRecord, listTurnSummaries, recordTurnSummary, };
+/** Loaded resume cursor. A resumed checkpoint always has its record. */
+export type TurnCheckpoint = {
+    resumed: true;
+    sliceId: number;
+    record: TurnRecord;
+} | {
+    resumed: false;
+    sliceId: 1;
+    record?: TurnRecord;
+};
+/**
+ * Lifecycle fields for a checkpoint write.
+ * Routing/metrics/provenance are only for SQL dual-write / resume restore.
+ */
+interface TurnCheckpointWrite {
+    conversationId: string;
+    turnId: string;
+    messages: PiMessage[];
+    modelId: string;
+    /** Required for running/paused; optional for completed/failed (falls back to stored). */
+    sliceId?: number;
+    actor?: Actor;
+    channelName?: string;
+    destination?: Destination;
+    destinationVisibility?: ConversationPrivacy;
+    dispatchId?: string;
+    dispatchOutcome?: AgentDispatchOutcome;
+    source?: Source;
+    surface?: AgentTurnSurface;
+    loadedSkillNames?: string[];
+    reasoningLevel?: string;
+    turnStartMessageIndex?: number;
+    trailingMessageProvenance?: ConversationMessageProvenance[];
+    turnContexts?: PluginTurnContext[];
+    durationMs?: number;
+    usage?: AgentTurnUsage;
+    errorMessage?: string;
+    resultMessageId?: string;
+}
+type ProgressCheckpointArgs = (TurnCheckpointWrite & {
+    mode: "running";
+    sliceId: number;
+}) | (TurnCheckpointWrite & {
+    mode: "paused";
+    reason: TurnPauseReason;
+    sliceId: number;
+});
+type TerminalCheckpointArgs = TurnCheckpointWrite & {
+    mode: "completed" | "failed";
+};
+/** Boundary safe to continue after auth/timeout (trim mid-assistant). */
+export declare function continuableMessages(messages: PiMessage[], fallback?: PiMessage[]): PiMessage[];
+/** Load resume cursor for one turn. */
+export declare function loadTurnCheckpoint(args: {
+    conversationId: string;
+    turnId: string;
+}): Promise<TurnCheckpoint>;
+/**
+ * Save turn progress.
+ *
+ * - `running` / `paused`: best-effort; returns the stored record or undefined
+ * - `completed` / `failed`: retries until write accepts; throws on hard failure
+ */
+export declare function saveTurnCheckpoint(args: ProgressCheckpointArgs): Promise<TurnRecord | undefined>;
+export declare function saveTurnCheckpoint(args: TerminalCheckpointArgs): Promise<void>;

package/dist/chat/task-execution/paused-turn.d.ts

@@ -0,0 +1,29 @@
+import { resumeSlackTurn } from "@/chat/runtime/slack-resume";
+import { type PausedTurnRequest } from "@/chat/task-execution/turn-wake";
+import type { AgentRunner } from "@/chat/runtime/agent-runner";
+import type { AgentRunRouting } from "@/chat/agent/request";
+/** Runtime ports for paused turn scheduling. */
+export interface PausedTurnOptions {
+    agentRunner: AgentRunner;
+    /** Exact persisted input ids accepted while running the paused turn. */
+    inputMessageIds?: readonly string[];
+    routingContext?: Pick<AgentRunRouting, "actor" | "credentialContext" | "destinationVisibility" | "dispatch" | "surface">;
+    resumeTurn?: typeof resumeSlackTurn;
+    wakePausedTurn?: (request: PausedTurnRequest) => Promise<void>;
+    scheduleSessionCompletedPluginTasks?: (params: {
+        conversationId: string;
+        sessionId: string;
+    }) => Promise<void>;
+}
+/** Per-worker controls for one paused turn. */
+export interface PausedTurnRunOptions {
+    shouldYield?: () => boolean;
+}
+/**
+ * Continue one paused Slack agent run from durable conversation state.
+ *
+ * Returns false when the session became stale before generation began.
+ */
+export declare function runPausedTurn(payload: PausedTurnRequest, options: PausedTurnOptions, runOptions?: PausedTurnRunOptions): Promise<boolean>;
+/** Resume the first valid paused Slack session for an idle conversation. */
+export declare function runNextPausedTurn(conversationId: string, options: PausedTurnOptions, runOptions?: PausedTurnRunOptions): Promise<boolean>;

package/dist/chat/task-execution/queue-signing.d.ts

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { type ConversationQueueMessage } from "./queue";
 export declare const CONVERSATION_WORK_QUEUE_SIGNATURE_MAX_SKEW_MS: number;
 declare const signedConversationQueueMessageSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
     conversationId: z.ZodString;
     signature: z.ZodString;
     signatureVersion: z.ZodLiteral<"v2">;

package/dist/chat/task-execution/queue.d.ts

@@ -1,6 +1,8 @@
 import { z } from "zod";
-/** Validate the conversation work hint sent through Vercel Queue. */
+export declare const CONVERSATION_QUEUE_SCHEMA_VERSION = 2;
+/** Validate the v2 conversation work hint sent through Vercel Queue. */
 export declare const conversationQueueMessageSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
     conversationId: z.ZodString;
 }, z.core.$strict>;
 /** Conversation work hint accepted by the queue callback and worker. */
@@ -22,6 +24,10 @@ export interface ConversationQueueSendOptions {
 export interface ConversationQueueSendResult {
     messageId?: string;
 }
+/**
+ * External transport for wake-up hints. Durable work stays in the mailbox;
+ * transports only need to accept one hint and may return a provider message id.
+ */
 export interface ConversationWorkQueue {
     send(message: ConversationQueueMessage, options?: ConversationQueueSendOptions): Promise<ConversationQueueSendResult | void>;
 }

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

@@ -274,7 +274,7 @@ export interface CreateSlackConversationWorkerOptions {
     crossActorMidRunMode?: CrossActorMidRunMode;
     getSlackAdapter: () => SlackAdapter;
     lookupSlackUser?: (teamId: string, userId: string) => Promise<SlackActorProfile | null | undefined>;
-    resumeAwaitingContinuation: (conversationId: string, options: {
+    runNextPausedTurn: (conversationId: string, options: {
         shouldYield: () => boolean;
     }) => Promise<boolean>;
     conversationStore?: ConversationStore;

package/dist/chat/task-execution/state.d.ts

@@ -7,8 +7,8 @@ declare class InvalidConversationRecordError extends Error {
 }
 /** Return whether an error means a stored conversation record failed validation. */
 export declare function isInvalidConversationRecordError(error: unknown): error is InvalidConversationRecordError;
-export declare const CONVERSATION_BY_ACTIVITY_INDEX_KEY = "junior:conversation:by-activity";
-export declare const CONVERSATION_ACTIVE_INDEX_KEY = "junior:conversation:active";
+export declare const CONVERSATION_BY_ACTIVITY_INDEX_KEY = "junior:conversation:v2:by-activity";
+export declare const CONVERSATION_ACTIVE_INDEX_KEY = "junior:conversation:v2:active";
 export declare const CONVERSATION_WORK_LEASE_TTL_MS = 90000;
 export declare const CONVERSATION_WORK_CHECK_IN_INTERVAL_MS = 15000;
 export declare const CONVERSATION_WORK_STALE_ENQUEUE_MS = 60000;
@@ -24,7 +24,7 @@ declare const inboundMessageSourceSchema: z.ZodEnum<{
     scheduler: "scheduler";
 }>;
 export type Source = z.output<typeof inboundMessageSourceSchema>;
-export type ExecutionStatus = "awaiting_resume" | "failed" | "idle" | "pending" | "running";
+export type ExecutionStatus = "paused" | "failed" | "idle" | "pending" | "running";
 declare const agentInputSchema: z.ZodObject<{
     attachments: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
     authorId: z.ZodOptional<z.ZodString>;
@@ -252,7 +252,7 @@ export declare function ackMessages(args: {
     state?: StateAdapter;
 }): Promise<boolean>;
 /** Mark the leased conversation as needing another queue-delivered slice. */
-export declare function requestConversationContinuation(args: {
+export declare function requestAnotherSlice(args: {
     conversationId: string;
     destination?: Destination;
     leaseToken: string;

package/dist/chat/task-execution/store.d.ts

@@ -1,6 +1,6 @@
 import type { StateAdapter } from "chat";
 import type { ConversationStore } from "@/chat/conversations/store";
-import type { ConversationWorkQueue } from "./queue";
+import { type ConversationWorkQueue } from "./queue";
 import * as workState from "./state";
 export { CONVERSATION_ACTIVE_INDEX_KEY, CONVERSATION_BY_ACTIVITY_INDEX_KEY, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS, CONVERSATION_WORK_LEASE_TTL_MS, CONVERSATION_WORK_MAX_DELIVERY_ATTEMPTS, CONVERSATION_WORK_MAX_RETRIES, CONVERSATION_WORK_STALE_ENQUEUE_MS, isFinalAttempt, isInvalidConversationRecordError, type AgentInput, type AttemptFailure, type AppendAndEnqueueInboundMessageResult, type AppendInboundMessageResult, type Conversation, type ConversationExecution, type ConversationWorkLease, type ConversationWorkState, type ExecutionStatus, type InboundMessage, type InboundMessageDelivery, type Lease, type RequestConversationWorkResult, type Source, type StartConversationWorkAcquired, type StartConversationWorkActive, type StartConversationWorkNoWork, type StartConversationWorkResult, } from "@/chat/task-execution/state";
 import type { AppendAndEnqueueInboundMessageResult, Conversation, InboundMessage } from "@/chat/task-execution/state";
@@ -136,7 +136,7 @@ export declare function ackMessages(args: {
     state?: StateAdapter;
 }): Promise<boolean>;
 /** Mark the leased conversation as needing another queue-delivered slice. */
-export declare function requestConversationContinuation(args: {
+export declare function requestAnotherSlice(args: {
     conversationId: string;
     destination: InboundMessage["destination"];
     leaseToken: string;

package/dist/chat/task-execution/turn-cursor-keys.d.ts

@@ -0,0 +1,6 @@
+/** Return the Redis key for one turn cursor. */
+export declare function turnCursorKey(conversationId: string, turnId: string): string;
+/** Return the Redis index key for one conversation's turns. */
+export declare function turnCursorIndexKey(conversationId: string): string;
+/** Return the lock key that serializes writes to one turn cursor. */
+export declare function turnCursorMutationKey(conversationId: string, turnId: string): string;

package/dist/chat/{state/turn-session.d.ts → task-execution/turn-cursor.d.ts}

@@ -1,11 +1,11 @@
 /**
- * Turn session records.
+ * Internal turn cursor storage for `checkpoint.ts`.
  *
- * These records track one user request across auth pauses, timeout slices, and
- * completion. Full Pi messages live in the durable conversation event store; this
- * record stores resumability metadata and a committed `seq` cursor into
- * `junior_conversation_events` so resumes can materialize the exact continuable
- * boundary without duplicating the event history.
+ * Callers outside `task-execution/` should use `checkpoint.ts` only.
+ * These records track one turn across auth pauses, timeout slices, and
+ * completion. Full Pi messages live in SQL conversation events; this store
+ * keeps resume metadata and a committed `seq` cursor into
+ * `junior_conversation_events`.
  */
 import type { Destination, Source } from "@sentry/junior-plugin-api";
 import { type PiMessage } from "@/chat/pi/messages";
@@ -15,12 +15,13 @@ import type { PluginTurnContext } from "@/chat/plugins/prompt";
 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";
+type TurnStatus = "running" | "paused" | "completed" | "failed" | "abandoned";
 export type AgentTurnSurface = "slack" | "api" | "scheduler" | "internal";
-export type AgentTurnResumeReason = "timeout" | "auth" | "yield" | "retry";
+export type TurnPauseReason = "timeout" | "auth" | "yield" | "retry";
 export type AgentDispatchOutcome = "blocked" | "completed" | "failed";
-export interface AgentTurnSessionRecord {
+export interface TurnRecord {
     channelName?: string;
+    schemaVersion: 2;
     version: number;
     conversationId: string;
     cumulativeDurationMs: number;
@@ -44,37 +45,38 @@ export interface AgentTurnSessionRecord {
      * replaces the singular execution actor, which is rebuilt at resume.
      */
     actors: Actor[];
-    resumeReason?: AgentTurnResumeReason;
+    resumeReason?: TurnPauseReason;
     resumedFromSliceId?: number;
-    sessionId: string;
+    turnId: string;
     sliceId: number;
     startedAtMs: number;
-    state: AgentTurnSessionStatus;
+    state: TurnStatus;
     surface?: AgentTurnSurface;
     traceId?: string;
     turnStartMessageIndex?: number;
     updatedAtMs: number;
 }
-export interface AgentTurnSessionSummary {
+export interface TurnSummary {
+    schemaVersion: 2;
     conversationId: string;
     dispatchId?: string;
     dispatchOutcome?: AgentDispatchOutcome;
     /** Provider-owned identifier returned after visible delivery is accepted. */
     resultMessageId?: string;
-    resumeReason?: AgentTurnResumeReason;
-    sessionId: string;
+    resumeReason?: TurnPauseReason;
+    turnId: string;
     sliceId: number;
-    state: AgentTurnSessionStatus;
+    state: TurnStatus;
     surface?: AgentTurnSurface;
     updatedAtMs: number;
     version: number;
 }
 /** 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: {
+export declare function getTurnRecord(conversationId: string, turnId: string): Promise<TurnRecord | undefined>;
+/** Read a turn cursor for resume, following a newer committed replacement while unfinished. */
+export declare function getTurnRecordForResume(conversationId: string, turnId: string): Promise<TurnRecord | undefined>;
+/** Commit stable Pi state and advance the turn cursor. */
+export declare function upsertTurnRecord(args: {
     channelName?: string;
     conversationId: string;
     cumulativeDurationMs?: number;
@@ -90,15 +92,15 @@ export declare function upsertAgentTurnSessionRecord(args: {
     loadedSkillNames?: string[];
     modelId: string;
     conversationStore?: ConversationStore;
-    sessionId: string;
+    turnId: string;
     sliceId: number;
-    state: AgentTurnSessionStatus;
+    state: TurnStatus;
     surface?: AgentTurnSurface;
     piMessages: PiMessage[];
     /** Provenance for trailing newly committed messages, such as steering. */
     trailingMessageProvenance?: ConversationMessageProvenance[];
     actor?: Actor;
-    resumeReason?: AgentTurnResumeReason;
+    resumeReason?: TurnPauseReason;
     reasoningLevel?: string;
     errorMessage?: string;
     resumedFromSliceId?: number;
@@ -106,9 +108,8 @@ export declare function upsertAgentTurnSessionRecord(args: {
     turnContexts?: PluginTurnContext[];
     turnStartMessageIndex?: number;
     ttlMs?: number;
-}): Promise<AgentTurnSessionRecord>;
-/** Record turn-session metadata without storing conversation messages. */
-export declare function recordAgentTurnSessionSummary(args: {
+}): Promise<TurnRecord>;
+type TurnSummaryWrite = {
     channelName?: string;
     conversationId: string;
     cumulativeDurationMs?: number;
@@ -117,7 +118,6 @@ export declare function recordAgentTurnSessionSummary(args: {
     dispatchId?: string;
     dispatchOutcome?: AgentDispatchOutcome;
     resultMessageId?: string;
-    /** Confirmed destination visibility; omit when unavailable. */
     destinationVisibility?: ConversationPrivacy;
     source?: Source;
     lastProgressAtMs?: number;
@@ -125,28 +125,38 @@ export declare function recordAgentTurnSessionSummary(args: {
     modelId?: string;
     conversationStore?: ConversationStore;
     actor?: Actor;
-    resumeReason?: AgentTurnResumeReason;
+    resumeReason?: TurnPauseReason;
     reasoningLevel?: string;
-    sessionId: string;
+    turnId: string;
     sliceId: number;
     startedAtMs?: number;
-    state: AgentTurnSessionStatus;
+    state: TurnStatus;
     surface?: AgentTurnSurface;
     traceId?: string;
     ttlMs?: number;
-}): Promise<void>;
-/** List retained turn-session recovery projections for one conversation. */
-export declare function listAgentTurnSessionSummariesForConversation(conversationId: string): Promise<AgentTurnSessionSummary[]>;
-/** Mark an unfinished turn session record as abandoned when a newer turn wins. */
-export declare function abandonAgentTurnSessionRecord(args: {
+};
+/** Record turn metadata without storing conversation messages. */
+export declare function recordTurnSummary(args: TurnSummaryWrite): Promise<void>;
+/** List retained turn recovery projections for one conversation. */
+export declare function listTurnSummaries(conversationId: string): Promise<TurnSummary[]>;
+/** Mark an unfinished turn cursor as abandoned when a newer turn wins. */
+export declare function abandonTurnRecord(args: {
     conversationId: string;
-    sessionId: string;
+    turnId: string;
     errorMessage?: string;
-}): Promise<AgentTurnSessionRecord | undefined>;
-/** Mark an unfinished turn session record as failed so it cannot resume. */
-export declare function failAgentTurnSessionRecord(args: {
+}): Promise<TurnRecord | undefined>;
+/** Mark an unfinished turn cursor as completed after delivery was accepted. */
+export declare function completeTurnRecord(args: {
+    conversationId: string;
+    expectedVersion: number;
+    resultMessageId?: string;
+    turnId: string;
+}): Promise<TurnRecord | undefined>;
+/** Mark an unfinished turn cursor as failed so it cannot resume. */
+export declare function failTurnRecord(args: {
     conversationId: string;
     expectedVersion: number;
-    sessionId: string;
+    turnId: string;
     errorMessage?: string;
-}): Promise<AgentTurnSessionRecord | undefined>;
+}): Promise<TurnRecord | undefined>;
+export {};

package/dist/chat/task-execution/turn-wake.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Continue a paused turn via the conversation work queue.
+ *
+ * Wake-only: mailbox/lease own liveness; this just nudges the worker.
+ */
+import type { StateAdapter } from "chat";
+import type { Destination } from "@sentry/junior-plugin-api";
+import type { ConversationStore } from "@/chat/conversations/store";
+import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
+export interface PausedTurnRequest {
+    conversationId: string;
+    destination: Destination;
+    expectedVersion: number;
+    turnId: string;
+}
+interface TurnWakeOptions {
+    nowMs?: number;
+    queue?: ConversationWorkQueue;
+    state?: StateAdapter;
+}
+/** Build the worker input for a paused turn. */
+export declare function getPausedTurnRequest(args: {
+    conversationId: string;
+    conversationStore?: ConversationStore;
+    turnId: string;
+}): Promise<PausedTurnRequest | undefined>;
+/** Wake the conversation worker for a paused turn. */
+export declare function wakePausedTurn(request: PausedTurnRequest, options?: TurnWakeOptions): Promise<void>;
+export {};

package/dist/chat/tasks/execution-stats.d.ts

@@ -20,6 +20,10 @@ export type TaskExecutionRecord = {
     status: TaskExecutionStatus;
     title?: string;
 };
+export type TaskRunRecord = TaskExecutionRecord & {
+    kind: TaskExecutionType;
+    taskId: string;
+};
 export type TaskExecutionStatusDay = {
     blocked: number;
     completed: number;
@@ -42,6 +46,14 @@ export declare function readTaskExecutionSummaries(type: TaskExecutionType, name
 export declare function readTaskExecutionDays(dayCount?: number, options?: {
     nowMs?: number;
 }): Promise<TaskExecutionDay[]>;
+/** Load the newest terminal task execution linked to one conversation, if any. */
+export declare function readTaskExecutionByConversationId(args: {
+    conversationId: string;
+    namespace?: string;
+}): Promise<{
+    kind: TaskExecutionType;
+    taskId: string;
+} | undefined>;
 /** Load newest-first executions for one task, with conversation titles when present. */
 export declare function readTaskExecutions(args: {
     kind: TaskExecutionType;
@@ -49,6 +61,15 @@ export declare function readTaskExecutions(args: {
     namespace?: string;
     taskId: string;
 }): Promise<TaskExecutionRecord[]>;
+/** Load newest-first executions for the supplied viewer-visible tasks. */
+export declare function readTaskRuns(args: {
+    limit: number;
+    namespace?: string;
+    tasks: Array<{
+        kind: TaskExecutionType;
+        taskId: string;
+    }>;
+}): Promise<TaskRunRecord[]>;
 /** Load a fixed trailing window of terminal executions for one task by status. */
 export declare function readTaskExecutionStatusDays(args: {
     dayCount?: number;

package/dist/chat/tasks/read.d.ts

@@ -1,11 +1,19 @@
 import type { User } from "@sentry/junior-plugin-api";
-import type { TaskExecutionList, TaskList } from "@/api/schema/task";
+import type { ConversationSourceTask } from "@/api/schema/conversation";
+import type { TaskExecutionList, TaskList, TaskRunList } from "@/api/schema/task";
 /** Read viewer-owned and public-workspace tasks as one bounded newest-first projection. */
 export declare function readViewerTasks(user: User): Promise<TaskList>;
+/** Read newest runs across the viewer-visible scheduled and event tasks. */
+export declare function readViewerTaskRuns(user: User): Promise<TaskRunList>;
 export declare class ViewerTaskNotFoundError extends Error {
     constructor();
 }
 /** Read one viewer-visible task and its newest terminal executions. */
 export declare function readViewerTaskExecutions(user: User, kind: "scheduled" | "event", id: string): Promise<TaskExecutionList>;
+/** Resolve the source task for one conversation when a terminal execution links it. */
+export declare function readConversationSourceTask(args: {
+    conversationId: string;
+    verifiedViewerEmail?: string;
+}): Promise<ConversationSourceTask | undefined>;
 /** Delete one viewer-owned scheduled or event task. */
 export declare function deleteViewerTask(user: User, kind: "scheduled" | "event", id: string): Promise<void>;

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

@@ -2,7 +2,7 @@ import type { FileUpload } from "chat";
 import type { Destination, Identity, LocalDestination, LocalSource, PluginEgress, SlackDestination, SlackSource, Source, User } from "@sentry/junior-plugin-api";
 import type { McpToolManager } from "@/chat/mcp/tool-manager";
 import type { SandboxWorkspace } from "@/chat/sandbox/workspace";
-import type { AgentTurnSurface } from "@/chat/state/turn-session";
+import type { AgentTurnSurface } from "@/chat/task-execution/checkpoint";
 import type { ThreadArtifactsState } from "@/chat/state/artifacts";
 import type { Skill } from "@/chat/skills";
 import type { LoadSkillMetadata } from "@/chat/tools/skill/load-skill";

package/dist/{chunk-2KLMGRRQ.js → chunk-27TEJTZO.js}

@@ -1,6 +1,6 @@
 import {
   DEFAULT_SQL_STATEMENT_TIMEOUT_MS
-} from "./chunk-7GVX5SOG.js";
+} from "./chunk-XFKIRN3Q.js";
 import {
   juniorDestinations,
   timestamptz

package/dist/{chunk-GZRWULXF.js → chunk-2LWPFSB4.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-6GWA276C.js";
 import {
   getDeploymentTelemetryAttributes
-} from "./chunk-WSWVWP2V.js";
+} from "./chunk-DS3J6WGY.js";
 
 // src/chat/logging.ts
 import path from "path";

package/dist/{chunk-NAINBOZQ.js → chunk-2UH3JI64.js}

@@ -5,12 +5,12 @@ import {
   juniorConversations,
   juniorIdentities,
   juniorUsers
-} from "./chunk-2KLMGRRQ.js";
+} from "./chunk-27TEJTZO.js";
 import {
   TURN_REASONING_LEVELS,
   getChatConfig,
   modelProfileSchema
-} from "./chunk-7GVX5SOG.js";
+} from "./chunk-XFKIRN3Q.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
@@ -20,7 +20,7 @@ import {
 } from "./chunk-F3B2YJ76.js";
 import {
   normalizeIdentityEmail
-} from "./chunk-GZRWULXF.js";
+} from "./chunk-2LWPFSB4.js";
 
 // src/chat/conversations/sql/store.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -376,16 +376,17 @@ function destinationUpsertFromDestination(args) {
   };
 }
 function executionStatusFromValue(value) {
-  if (value === "awaiting_resume" || value === "failed" || value === "idle" || value === "pending" || value === "running") {
+  if (value === "awaiting_resume" || value === "paused") return "paused";
+  if (value === "failed" || value === "idle" || value === "pending" || value === "running") {
     return value;
   }
   throw new Error("Conversation record execution status is invalid");
 }
+function executionStatusToSql(status) {
+  return status === "paused" ? "awaiting_resume" : status;
+}
 function actorFromIdentityRow(identity, userDisplayName) {
-  if (!identity) {
-    return void 0;
-  }
-  if (identity.provider !== "slack") {
+  if (!identity || identity.provider !== "slack") {
     return void 0;
   }
   const fullName = userDisplayName?.trim() ? userDisplayName : identity.displayName;
@@ -816,7 +817,7 @@ var SqlStore = class {
       lastActivityAt: dateFromMs2(conversation.lastActivityAtMs),
       updatedAt: dateFromMs2(conversation.updatedAtMs),
       executionUpdatedAt: conversation.execution.updatedAtMs === void 0 ? null : dateFromMs2(conversation.execution.updatedAtMs),
-      executionStatus: conversation.execution.status,
+      executionStatus: executionStatusToSql(conversation.execution.status),
       runId: conversation.execution.runId ?? null,
       lastCheckpointAt: conversation.execution.lastCheckpointAtMs === void 0 ? null : dateFromMs2(conversation.execution.lastCheckpointAtMs),
       lastEnqueuedAt: conversation.execution.lastEnqueuedAtMs === void 0 ? null : dateFromMs2(conversation.execution.lastEnqueuedAtMs),