@sentry/junior 0.144.0 → 0.145.0

package/dist/{catalog-runtime-DWVYKDC6.js → catalog-runtime-QLAC4Q3W.js}

@@ -1,16 +1,16 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-ZF3N3JD6.js";
-import "./chunk-A67GZN73.js";
+} from "./chunk-SIN3MXH6.js";
+import "./chunk-CD2XFGYQ.js";
 import "./chunk-RUIXF3YQ.js";
 import "./chunk-HZF5P5UN.js";
 import "./chunk-F3B2YJ76.js";
-import "./chunk-RIFJUJSI.js";
+import "./chunk-2LWPFSB4.js";
 import "./chunk-6GWA276C.js";
 import "./chunk-OOUNJNMR.js";
 import "./chunk-H4HBKISO.js";
-import "./chunk-WTX2RFJG.js";
-import "./chunk-I44JB7HQ.js";
+import "./chunk-DS3J6WGY.js";
+import "./chunk-GDV5LXRA.js";
 import "./chunk-MLKGABMK.js";
 export {
   pluginCatalogRuntime

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

@@ -22,7 +22,7 @@ import type { SlackConversationContext } from "@/chat/slack/conversation-context
 import type { ThreadArtifactsState } from "@/chat/state/artifacts";
 import type { ConversationPendingAuthState } from "@/chat/state/conversation";
 import type { ConversationMessageProvenance } from "@/chat/conversations/provenance";
-import type { AgentTurnSurface } from "@/chat/state/turn-session";
+import type { AgentTurnSurface } from "@/chat/task-execution/checkpoint";
 import type { ToolExecutionReport } from "@/chat/tool-support/tool-execution-report";
 import type { SlackActionToken } from "@/chat/slack/action-token";
 import type { TurnReasoningLevel } from "@/chat/reasoning-level";

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

@@ -1,26 +1,20 @@
 /**
- * Run resumability.
+ * In-memory resume helpers for one execution slice.
  *
- * Owns the durable state that lets a run slice stop without losing work:
- * safe-boundary checkpoints, the durable input commit, resume snapshots, and
- * persistence of the expected endings (cooperative yield, continuable
- * timeout, auth pause) translated into `AgentRunOutcome` values so the
- * executor's catch block stays a thin translation over genuine errors.
+ * Durable writes go through `saveTurnCheckpoint` only.
  */
 import type { Destination, Source } from "@sentry/junior-plugin-api";
 import type { PiMessage } from "@/chat/pi/messages";
 import type { ConversationMessageProvenance } from "@/chat/conversations/provenance";
 import { CooperativeTurnYieldError } from "@/chat/runtime/turn";
 import type { AgentRunOutcome } from "@/chat/runtime/agent-run-outcome";
-import type { AgentTurnSurface } from "@/chat/state/turn-session";
 import type { Actor } from "@/chat/actor";
-import { loadTurnSessionRecord } from "@/chat/services/turn-session-record";
+import { type AgentTurnSurface, type TurnCheckpoint } from "@/chat/task-execution/checkpoint";
 import { type AuthorizationPauseError } from "@/chat/services/auth-pause";
 import { type AgentTurnUsage } from "@/chat/usage";
 import { type AgentRunDurability } from "@/chat/agent/request";
 import type { PluginTurnContext } from "@/chat/plugins/prompt";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
-type LoadedSessionRecordState = Awaited<ReturnType<typeof loadTurnSessionRecord>>;
 interface ResumeStateArgs {
     channelName?: string;
     destination: Destination;
@@ -35,14 +29,14 @@ interface ResumeStateArgs {
     runSource: Source;
     conversationId: string;
     turnId: string;
-    sessionRecordState: LoadedSessionRecordState;
+    checkpoint: TurnCheckpoint;
     startedAtMs: number;
     surface: AgentTurnSurface;
 }
 type AuthPauseOutcome = Extract<AgentRunOutcome, {
     status: "awaiting_auth";
 }>;
-/** Create the run's resume state: checkpoints, snapshots, and ending translation. */
+/** Create resume state for one slice. */
 export declare function createResumeState(args: ResumeStateArgs): {
     readonly inputCommitted: boolean;
     readonly beforeMessageCount: number;
@@ -50,7 +44,7 @@ export declare function createResumeState(args: ResumeStateArgs): {
     setTurnStartMessageIndex(index: number | undefined): void;
     setBeforeMessageCount(count: number): void;
     setTurnContexts(contexts: PluginTurnContext[]): void;
-    /** Adopt an already committed epoch replacement as every resume baseline. */
+    /** Use an already committed boundary as the resume baseline. */
     adoptCommittedBoundary(messages: PiMessage[]): void;
     captureResumeSnapshot(messages: PiMessage[]): void;
     getResumeSnapshot(currentMessages: PiMessage[]): PiMessage[];
@@ -58,11 +52,8 @@ export declare function createResumeState(args: ResumeStateArgs): {
     commitInput(): Promise<void>;
     persistSafeBoundary(messages: PiMessage[], trailingMessageProvenance?: ConversationMessageProvenance[]): Promise<boolean>;
     requireDurableInputCheckpoint(messages: PiMessage[], trailingMessageProvenance?: ConversationMessageProvenance[]): Promise<boolean>;
-    /** Prepare a cooperative yield at the current durable boundary. */
     prepareYieldIfDue(currentMessages: PiMessage[]): CooperativeTurnYieldError | undefined;
-    /** Persist an auth pause; only a durable pause may return `awaiting_auth`. */
     parkForAuth(pause: AuthorizationPauseError, currentUsage?: AgentTurnUsage): Promise<AuthPauseOutcome>;
-    /** Persist a yield, retry, or timeout as a suspended run. */
     translateSuspension(ending: {
         currentUsage?: AgentTurnUsage;
         error: unknown;

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

@@ -25,7 +25,7 @@ import type { OAuthAuthorization } from "@/chat/oauth-authorization";
 import type { Actor } from "@/chat/actor";
 import type { ThreadArtifactsState } from "@/chat/state/artifacts";
 import type { AuthorizationPauseError } from "@/chat/services/auth-pause";
-import type { AgentTurnSurface } from "@/chat/state/turn-session";
+import type { AgentTurnSurface } from "@/chat/task-execution/checkpoint";
 import { type AgentRunDurability, type AgentRunObservers, type AgentRunPolicy, type AgentRunRouting, type AgentRunState } from "@/chat/agent/request";
 import type { ResumeState } from "@/chat/agent/resume";
 interface ToolWiringArgs {

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

@@ -1,7 +1,7 @@
 import type { DispatchOptions, DestinationVisibility, ReplyAttribution, Source, SlackDestination } from "@sentry/junior-plugin-api";
 import type { CredentialContext, CredentialSubject, CredentialSystemActor } from "@/chat/credentials/context";
 import type { AgentRunRouting } from "@/chat/agent/request";
-import type { AgentTurnSurface } from "@/chat/state/turn-session";
+import type { AgentTurnSurface } from "@/chat/task-execution/checkpoint";
 import type { ChannelConfigurationService } from "@/chat/configuration/types";
 export type DispatchStatus = "pending" | "running" | "awaiting_resume" | "completed" | "failed" | "blocked";
 export type SlackDispatchOptions = Omit<DispatchOptions, "destination"> & {

package/dist/chat/app/conversation-work.d.ts

@@ -0,0 +1,24 @@
+import type { SlackAdapter } from "@chat-adapter/slack";
+import type { StateAdapter } from "chat";
+import type { AgentRunner } from "@/chat/runtime/agent-runner";
+import type { ConversationStore } from "@/chat/conversations/store";
+import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
+import type { VercelConversationWorkCallbackOptions } from "@/chat/task-execution/vercel-callback";
+import { createSlackRuntime } from "./factory";
+import type { JuniorRuntimeServiceOverrides } from "./services";
+interface ConversationWorkOptions {
+    agentRunner: AgentRunner;
+    conversationStore: ConversationStore;
+    getSlackAdapter: () => SlackAdapter;
+    queue: ConversationWorkQueue;
+    services?: JuniorRuntimeServiceOverrides;
+    state?: StateAdapter;
+}
+/**
+ * Compose conversation work once for production and integration tests.
+ * Environment-specific queue, state, Slack, and agent adapters stop here.
+ */
+export declare function createConversationWork(options: ConversationWorkOptions): VercelConversationWorkCallbackOptions & {
+    runtime: ReturnType<typeof createSlackRuntime>;
+};
+export {};

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

@@ -10,6 +10,10 @@ import type { TurnReasoningLevel } from "@/chat/reasoning-level";
 import type { PluginTurnContext } from "@/chat/plugins/prompt";
 import type { ThreadConversationState } from "@/chat/state/conversation";
 import type { AssistantMessage } from "@earendil-works/pi-ai";
+/** A checkpoint tried to replace already committed agent history. */
+export declare class AgentHistoryBranchError extends Error {
+    constructor(conversationId: string);
+}
 interface ScopedConversation {
     conversationId: string;
 }
@@ -38,9 +42,13 @@ 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 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.
+ * Append newly stable native history items.
+ *
+ * Checkpoints are append-only against the durable identity of the committed
+ * prefix (role, timestamp, content; tool results also match call id). A shorter
+ * history or a true content branch is rejected — only compaction and handoff may
+ * intentionally replace active model history. In-place Pi mutations of already
+ * committed assistant envelopes (usage/stopReason) do not block the suffix.
  */
 export declare function commitMessages(args: {
     conversationId: string;

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

@@ -5,7 +5,7 @@ import type { Location } from "@/chat/conversations/location";
 import type { SessionSource } from "@/chat/source";
 import type { AgentTurnUsage } from "@/chat/usage";
 export type ConversationSource = "api" | "internal" | "local" | "plugin" | "resource_event" | "scheduler" | "slack";
-export type ConversationStatus = "awaiting_resume" | "failed" | "idle" | "pending" | "running";
+export type ConversationStatus = "paused" | "failed" | "idle" | "pending" | "running";
 export interface ConversationExecution {
     lastCheckpointAtMs?: number;
     lastEnqueuedAtMs?: number;

package/dist/chat/runtime/agent-run-outcome.d.ts

@@ -3,7 +3,7 @@ import type { AgentTurnUsage } from "@/chat/usage";
 /**
  * How an agent run ended. `completed` carries the terminal result (success or
  * failure — `result.diagnostics` distinguishes them). `suspended` means the run
- * persisted an awaiting_resume session record and stopped at a safe boundary;
+ * persisted an paused session record and stopped at a safe boundary;
  * the caller resumes it by scheduling a continuation against `resumeVersion`,
  * the session record's optimistic-concurrency version. `awaiting_auth` means
  * the run parked for user authorization.

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

@@ -15,20 +15,20 @@ import { type PrepareTurnStateInput, type QueuedTurnMessage, type TurnToolInvoca
 import { type ConversationMemoryService } from "@/chat/services/conversation-memory";
 import type { ContextCompactor } from "@/chat/services/context-compaction";
 import { lookupSlackUser } from "@/chat/slack/user";
-import type { AgentContinueRequest } from "@/chat/services/agent-continue";
+import type { PausedTurnRequest } from "@/chat/task-execution/turn-wake";
 import type { ConversationTurnLifecycle } from "@/chat/conversations/turn-lifecycle";
 import type { DispatchTurnContext, DispatchTurnResult } from "@/chat/agent-dispatch/types";
 export interface ReplyExecutorServices {
     agentRunner: AgentRunner;
     contextCompactor: ContextCompactor;
     generateThreadTitle: ConversationMemoryService["generateThreadTitle"];
-    getAwaitingAgentContinueRequest: (args: {
+    getPausedTurnRequest: (args: {
         conversationId: string;
-        sessionId: string;
-    }) => Promise<AgentContinueRequest | undefined>;
+        turnId: string;
+    }) => Promise<PausedTurnRequest | undefined>;
     lookupSlackUser: typeof lookupSlackUser;
     turnLifecycle: ConversationTurnLifecycle;
-    scheduleAgentContinue: (request: AgentContinueRequest) => Promise<void>;
+    wakePausedTurn: (request: PausedTurnRequest) => Promise<void>;
     scheduleSessionCompletedPluginTasks: (params: {
         conversationId: string;
         sessionId: string;

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

@@ -19,6 +19,12 @@ interface ResumeSlackTurnArgs {
     messageTs?: SlackMessageTs;
     replyContext?: ResumeReplyContext;
     lockKey?: string;
+    /**
+     * When true, the caller already holds the conversation work lease.
+     * Skip the second resume lock so queue continue is one owner, not two.
+     * OAuth and other out-of-band resumes leave this false.
+     */
+    ownsConversationLease?: boolean;
     initialText?: string;
     initialStatus?: AssistantStatusSpec;
     agentRunner: AgentRunner;
@@ -58,11 +64,13 @@ interface ResumePreparedTurn {
     onPostDeliveryCommitFailure?: (error: unknown) => Promise<void>;
 }
 /**
- * Resume a paused Slack turn under the normal thread lock.
+ * Resume a paused Slack turn.
  *
- * 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.
+ * Queue continues pass `ownsConversationLease` and skip the second lock
+ * (worker lease is already held). OAuth and other out-of-band resumes still
+ * take the thread lock. Started resumes own their completion side effects.
+ * 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/state/locks.d.ts

@@ -1,7 +1,35 @@
 import type { Lock, StateAdapter } from "chat";
 export declare const ACTIVE_LOCK_TTL_MS = 90000;
+export declare const MUTATION_LOCK_TTL_MS = 10000;
 /**
  * Acquire a lock for long-running work that the queued state adapter should
  * keep alive while the owning invocation is still making progress.
  */
 export declare function acquireActiveLock(state: StateAdapter, threadId: string): Promise<Lock | null>;
+type LockAttempt<T> = {
+    acquired: false;
+} | {
+    acquired: true;
+    value: T;
+};
+/**
+ * Run work under one lock, optionally waiting for the current owner.
+ * `keepAlive` is for multi-store mutations that must retain ownership until all
+ * side effects finish; callers should still fence each blind write.
+ */
+export declare function withLock<T>(state: StateAdapter, key: string, run: (lock: Lock) => Promise<T>, options?: {
+    keepAlive?: boolean;
+    retryMs?: number;
+    ttlMs?: number;
+    waitMs?: number;
+}): Promise<LockAttempt<T>>;
+/**
+ * Prove lock ownership immediately before a blind write.
+ *
+ * Whole-record mutations must stop if their lock expired rather than overwrite
+ * state committed by a newer owner.
+ */
+export declare function fenceLock(state: StateAdapter, lock: Lock, ttlMs?: number): Promise<void>;
+/** Run work under the active lock, reporting contention without ambiguity. */
+export declare function withActiveLock<T>(state: StateAdapter, key: string, run: () => Promise<T>): Promise<LockAttempt<T>>;
+export {};

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;