@sentry/junior 0.144.0 → 0.146.0

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

@@ -1,16 +1,16 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-ZF3N3JD6.js";
-import "./chunk-A67GZN73.js";
+} from "./chunk-PB222GIA.js";
+import "./chunk-37JJDS4H.js";
 import "./chunk-RUIXF3YQ.js";
 import "./chunk-HZF5P5UN.js";
 import "./chunk-F3B2YJ76.js";
-import "./chunk-RIFJUJSI.js";
+import "./chunk-B63BF443.js";
 import "./chunk-6GWA276C.js";
 import "./chunk-OOUNJNMR.js";
 import "./chunk-H4HBKISO.js";
-import "./chunk-WTX2RFJG.js";
-import "./chunk-I44JB7HQ.js";
+import "./chunk-HQE6EJS5.js";
+import "./chunk-F7REGDKO.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,48 +1,39 @@
 /**
- * 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;
     destinationVisibility?: ConversationPrivacy;
     dispatchId?: string;
     durability: AgentRunDurability;
-    getLoadedSkillNames: () => string[];
-    getModelId: () => string;
-    getReasoningLevel: () => string | undefined;
     recordActiveMcpProviders: () => Promise<void>;
     actor?: Actor;
     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 +41,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 +49,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/skills.d.ts

@@ -13,5 +13,4 @@ export declare function restoreSkillRuntime(args: {
     invokedSkill: SkillMetadata | null;
     priorPiMessages: PiMessage[] | undefined;
     skillSandbox: SkillSandbox;
-    syncLoadedSkillNamesForResume: () => void;
 }): Promise<void>;

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 {
@@ -66,7 +66,6 @@ interface ToolWiringArgs {
     state: AgentRunState;
     supportsImageInput: () => boolean;
     surface: AgentTurnSurface;
-    syncLoadedSkillNamesForResume: () => void;
     toolCalls: string[];
     userInput: string;
 }

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/message-search.d.ts

@@ -0,0 +1,32 @@
+/** One relevant chat-message match from a prior conversation. */
+export interface ConversationMessageSearchResult {
+    channelName?: string;
+    conversationId: string;
+    excerpt: string;
+    messageCreatedAtMs: number;
+    messageId: string;
+    providerDestinationId: string;
+    role: "assistant" | "user";
+}
+/** Runtime-derived public workspace scope for cross-conversation search. */
+export interface ConversationMessageSearchScope {
+    kind: "public_provider_tenant";
+    provider: "slack";
+    providerTenantId: string;
+}
+/** Optional filters that narrow retained public workspace search. */
+export interface ConversationMessageSearchFilters {
+    /** Slack channel id of the conversation destination. */
+    channelId?: string;
+    /** Full-text query over retained visible message text. */
+    query?: string;
+}
+/** Search retained public messages within an authorized workspace. */
+export interface ConversationMessageSearchStore {
+    search(args: {
+        currentConversationId: string;
+        filters: ConversationMessageSearchFilters;
+        limit: number;
+        scope: ConversationMessageSearchScope;
+    }): Promise<ConversationMessageSearchResult[]>;
+}

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/sql/message-search.d.ts

@@ -0,0 +1,4 @@
+import type { JuniorSqlDatabase } from "@/db/db";
+import type { ConversationMessageSearchStore } from "../message-search";
+/** Create a SQL-backed public workspace message search store. */
+export declare function createSqlConversationMessageSearchStore(executor: JuniorSqlDatabase): ConversationMessageSearchStore;

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/conversations/tool-source.d.ts

@@ -0,0 +1,5 @@
+/** Deferred tool catalog source for retained Junior conversations. */
+export declare const CONVERSATIONS_TOOL_SOURCE: {
+    readonly id: "conversations";
+    readonly description: "Search messages and events in retained Junior conversations.";
+};

package/dist/chat/db.d.ts

@@ -1,6 +1,6 @@
 import type { ConversationStore } from "@/chat/conversations/store";
 import type { ConversationEventStore } from "@/chat/conversations/history";
-import type { ConversationSearchStore } from "@/chat/conversations/search";
+import type { ConversationMessageSearchStore } from "@/chat/conversations/message-search";
 import type { JuniorDatabase, JuniorSqlExecutor } from "@/db/db";
 /** Return the process SQL executor for SQL-specific queries and transactions. */
 export declare function getSqlExecutor(): JuniorSqlExecutor;
@@ -11,6 +11,6 @@ export declare function getConversationStore(): ConversationStore;
 /** Return the canonical SQL-backed conversation event store. */
 export declare function getConversationEventStore(): ConversationEventStore;
 /** Return the SQL-backed public provider-tenant conversation search store. */
-export declare function getConversationSearchStore(): ConversationSearchStore;
+export declare function getConversationMessageSearchStore(): ConversationMessageSearchStore;
 /** Close the process SQL database when it has been opened. */
 export declare function closeDb(): Promise<void>;

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/slack/message/attachments.d.ts

@@ -0,0 +1,2 @@
+/** Render legacy attachment fields so attachment-only messages still carry context. */
+export declare function renderAttachmentText(input: unknown): string;

package/dist/chat/slack/message/blocks.d.ts

@@ -0,0 +1,2 @@
+/** Render visible block text without exposing hidden interaction data. */
+export declare function renderBlockText(value: unknown): string;

package/dist/chat/slack/message/content.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Slack message content projection.
+ *
+ * This module is the typed entry point for agent-visible Slack text. Raw block
+ * and attachment details stay behind this boundary.
+ */
+import { type Message } from "chat";
+/** Agent-visible content projected from a Slack message. */
+export interface MessageContent {
+    attachmentText: string;
+    hasAttachments: boolean;
+    text: string;
+    topLevelText: string;
+}
+/** Replace top-level text while preserving the parsed attachment projection. */
+export declare function replaceTopLevelText(content: Pick<MessageContent, "attachmentText">, text: string): string;
+/** Parse the agent-visible content and attachment state of a Slack message. */
+export declare function parseContent(message: Pick<Message, "attachments" | "formatted" | "raw" | "text">): MessageContent;

package/dist/chat/slack/message/identity.d.ts

@@ -0,0 +1,7 @@
+import type { Message } from "chat";
+import { type SlackMessageTs } from "@/chat/slack/timestamp";
+/**
+ * Preserve the native Slack message timestamp when a synthetic message ID is
+ * used for routing or deduplication.
+ */
+export declare function getMessageTimestamp(message: Pick<Message, "id" | "raw">): SlackMessageTs | undefined;

package/dist/chat/slack/tools/{conversation-search.d.ts → conversation-message-search.d.ts}

@@ -1,28 +1,30 @@
-import type { ConversationSearchScope, ConversationSearchStore } from "@/chat/conversations/search";
+import type { ConversationMessageSearchScope, ConversationMessageSearchStore } from "@/chat/conversations/message-search";
 import { getSlackMessagePermalink } from "@/chat/slack/outbound";
-interface ConversationSearchToolDeps {
+interface ConversationMessageSearchToolDeps {
     getPermalink?: typeof getSlackMessagePermalink;
-    store?: ConversationSearchStore;
+    store?: ConversationMessageSearchStore;
 }
-/** Create a tool that searches retained public Junior threads across an authorized Slack workspace. */
-export declare function createSlackConversationSearchTool(scope: ConversationSearchScope, currentConversationId: string, deps?: ConversationSearchToolDeps): Omit<import("../../tools/definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+/** Create a tool that searches retained public messages in an authorized Slack workspace. */
+export declare function createSlackConversationMessageSearchTool(scope: ConversationMessageSearchScope, currentConversationId: string, deps?: ConversationMessageSearchToolDeps): Omit<import("../../tools/definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
     inputSchema: import("../../tools/definition").JsonSchemaObject;
     outputSchema: import("../../tools/definition").JsonSchemaObject;
     prepareArguments(args: unknown): {
-        query: string;
+        channel_id?: string | null | undefined;
+        query?: string | null | undefined;
         limit?: number | null | undefined;
     };
     execute?: ((input: unknown, options: import("../../tools/definition").ToolExecuteOptions) => {
         [x: string]: unknown;
-        query: string;
         count: number;
-        threads: {
+        matches: {
+            channel_id: string;
             conversation_id: string;
-            thread_ts: string;
+            excerpt: string;
             message_id: string;
             message_role: "user" | "assistant";
             message_timestamp: string;
-            excerpt: string;
+            thread_ts: string;
+            channel_name?: string | undefined;
             permalink?: string | undefined;
         }[];
         target?: string | undefined;
@@ -31,17 +33,20 @@ export declare function createSlackConversationSearchTool(scope: ConversationSea
             arguments: Record<string, unknown>;
             reason?: string | undefined;
         } | undefined;
+        channel_id?: string | undefined;
+        query?: string | undefined;
     } | Promise<{
         [x: string]: unknown;
-        query: string;
         count: number;
-        threads: {
+        matches: {
+            channel_id: string;
             conversation_id: string;
-            thread_ts: string;
+            excerpt: string;
             message_id: string;
             message_role: "user" | "assistant";
             message_timestamp: string;
-            excerpt: string;
+            thread_ts: string;
+            channel_name?: string | undefined;
             permalink?: string | undefined;
         }[];
         target?: string | undefined;
@@ -50,6 +55,8 @@ export declare function createSlackConversationSearchTool(scope: ConversationSea
             arguments: Record<string, unknown>;
             reason?: string | undefined;
         } | undefined;
+        channel_id?: string | undefined;
+        query?: string | undefined;
     }>) | undefined;
 };
 export {};

package/dist/chat/slack/tools/user-lookup.d.ts

@@ -1,5 +1,6 @@
+import type { SlackTeamId } from "@/chat/slack/ids";
 /** Create the tool that resolves Slack users by ID, handle, or email. */
-export declare function createSlackUserLookupTool(): Omit<import("../../tools/definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+export declare function createSlackUserLookupTool(teamId: SlackTeamId): Omit<import("../../tools/definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
     inputSchema: import("../../tools/definition").JsonSchemaObject;
     outputSchema: import("../../tools/definition").JsonSchemaObject;
     prepareArguments(args: unknown): {

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,84 @@
+/**
+ * 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.
+ * Profile, reasoning, concrete model id, and skills are not checkpoint fields.
+ */
+interface TurnCheckpointWrite {
+    conversationId: string;
+    turnId: string;
+    messages: PiMessage[];
+    /** 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;
+    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">;