@sentry/junior 0.71.2 → 0.72.0

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

@@ -1,10 +1,4 @@
 import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
-/** Re-drive stale turn continuations whose internal callback vanished. */
-export declare function recoverStaleTimeoutResumes(args: {
-    conversationWorkQueue?: ConversationWorkQueue;
-    limit?: number;
-    nowMs: number;
-}): Promise<number>;
 /** Re-drive stale core dispatches before invoking plugin heartbeat hooks. */
 export declare function recoverStaleDispatches(args: {
     limit?: number;

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

@@ -1,3 +1,4 @@
+import type { ConversationPrivacy } from "@/chat/conversation-privacy";
 /** Thrown when an MCP failure should be returned as a model-visible tool error. */
 export declare class McpToolError extends Error {
     constructor(message: string);
@@ -6,3 +7,5 @@ export declare class McpToolError extends Error {
 export declare function getMcpAwareErrorType(error: unknown, fallback: string): string;
 /** Return the display-safe error message for MCP-aware tool failures. */
 export declare function getMcpAwareErrorMessage(error: unknown): string;
+/** Return an error message safe for logs and span attributes. */
+export declare function getMcpAwareTelemetryMessage(error: unknown, privacy: ConversationPrivacy | undefined): string;

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

@@ -8,6 +8,7 @@
  */
 import type { ImageContent, TextContent } from "@earendil-works/pi-ai";
 import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+import { type ConversationPrivacy } from "@/chat/conversation-privacy";
 import type { SkillMetadata } from "@/chat/skills";
 import type { PluginDefinition } from "@/chat/plugins/types";
 import { McpAuthorizationRequiredError, type PluginMcpToolCallResult } from "./client";
@@ -36,7 +37,10 @@ export interface ManagedMcpToolDescriptor {
 }
 type ActiveMcpSkill = Pick<SkillMetadata, "name" | "pluginProvider">;
 export interface ManagedMcpTool extends ManagedMcpToolDescriptor {
-    execute: (args: Record<string, unknown>) => Promise<ManagedMcpToolResult>;
+    execute: (args: Record<string, unknown>, options?: {
+        conversationPrivacy?: ConversationPrivacy;
+        toolCallId?: string;
+    }) => Promise<ManagedMcpToolResult>;
 }
 export declare class McpToolManager {
     private readonly options;

package/dist/chat/plugins/agent-hooks.d.ts

@@ -1,7 +1,8 @@
-import type { AgentPluginRequester, AgentPluginRoute, PluginOperationalReport, SlackConversationLink, JuniorPluginRegistration } from "@sentry/junior-plugin-api";
+import type { AgentPluginRoute, PluginOperationalReport, SlackConversationLink, JuniorPluginRegistration } from "@sentry/junior-plugin-api";
 import type { ToolDefinition } from "@/chat/tools/definition";
 import type { ToolRuntimeContext } from "@/chat/tools/types";
 import type { SandboxInstance } from "@/chat/sandbox/workspace";
+import type { Requester } from "@/chat/requester";
 /** Signal that a plugin intentionally denied a tool execution. */
 export declare class AgentPluginHookDeniedError extends Error {
     constructor(message: string);
@@ -37,5 +38,5 @@ export declare function getAgentPluginSlackConversationLink(conversationId: stri
 export declare function getAgentPluginOperationalReports(nowMs?: number): Promise<PluginOperationalReport[]>;
 /** Create one runner over runtime hook plugins registered by the app. */
 export declare function createAgentPluginHookRunner(input?: {
-    requester?: AgentPluginRequester;
+    requester?: Requester;
 }): AgentPluginHookRunner;

package/dist/chat/requester.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Canonical Slack requester identity.
+ *
+ * Runtime requesters are always workspace-scoped Slack actors. Stored requester
+ * parsing remains explicit so legacy durable records can resume without
+ * repairing malformed team or user ids.
+ */
+import { z } from "zod";
+export declare const storedSlackRequesterSchema: z.ZodObject<{
+    email: z.ZodOptional<z.ZodString>;
+    fullName: z.ZodOptional<z.ZodString>;
+    platform: z.ZodOptional<z.ZodLiteral<"slack">>;
+    slackUserId: z.ZodOptional<z.ZodString>;
+    slackUserName: z.ZodOptional<z.ZodString>;
+    teamId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export interface Requester {
+    email?: string;
+    fullName?: string;
+    platform: "slack";
+    teamId: string;
+    userId: string;
+    userName?: string;
+}
+export interface SlackRequesterProfile {
+    email?: string;
+    fullName?: string;
+    userName?: string;
+}
+export type StoredSlackRequester = z.output<typeof storedSlackRequesterSchema>;
+interface RequesterInput {
+    email?: string;
+    fullName?: string;
+    platform?: "slack";
+    teamId?: string;
+    userId?: string;
+    userName?: string;
+}
+/** Keep actor ids exact at platform boundaries before they enter owned state. */
+export declare function parseActorUserId(value: unknown): string | undefined;
+/** Assert persisted actor ids without read-side repair. */
+export declare function isActorUserId(value: string | undefined): value is string;
+/** Build Junior's canonical requester from exact Slack team/user ids and profile data. */
+export declare function createRequester(input: RequesterInput | undefined, context: {
+    teamId?: string;
+    userId?: string;
+}): Requester | undefined;
+/** Build Junior's canonical requester from Slack profile data. */
+export declare function createSlackRequester(teamId: string, userId: string, profile: SlackRequesterProfile | null | undefined): Requester;
+/** Parse a serialized Slack requester that crossed a runtime boundary. */
+export declare function parseStoredSlackRequester(value: unknown): StoredSlackRequester | undefined;
+/** Convert a runtime Slack requester into its durable session shape. */
+export declare function toStoredSlackRequester(requester: Requester): StoredSlackRequester;
+/** Rebuild a runtime requester from durable Slack requester state. */
+export declare function createRequesterFromStoredSlackRequester(args: {
+    requester?: StoredSlackRequester;
+    teamId: string;
+    userId: string;
+}): Requester;
+export {};

package/dist/chat/respond.d.ts

@@ -10,17 +10,13 @@ import type { SlackConversationContext } from "@/chat/slack/conversation-context
 import { type AssistantReply, type AgentTurnDiagnostics } from "@/chat/services/turn-result";
 import type { AgentTurnSurface } from "@/chat/state/turn-session";
 import type { CredentialContext } from "@/chat/credentials/context";
+import { type Requester } from "@/chat/requester";
 import { type AuthorizationFlowMode } from "@/chat/services/auth-pause";
 export type { AssistantReply, AgentTurnDiagnostics };
 export interface ReplyRequestContext {
     skillDirs?: string[];
     credentialContext?: CredentialContext;
-    requester?: {
-        userId?: string;
-        userName?: string;
-        fullName?: string;
-        email?: string;
-    };
+    requester?: Requester;
     slackConversation?: SlackConversationContext;
     destination?: Destination;
     surface?: AgentTurnSurface;

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

@@ -0,0 +1,25 @@
+import { resumeSlackTurn } from "@/chat/runtime/slack-resume";
+import { type AgentContinueRequest } from "@/chat/services/agent-continue";
+import type { generateAssistantReply } from "@/chat/respond";
+/** Runtime ports for agent continuation scheduling. */
+export interface AgentContinueRunnerOptions {
+    generateReply?: typeof generateAssistantReply;
+    resumeTurn?: typeof resumeSlackTurn;
+    scheduleAgentContinue?: (request: AgentContinueRequest) => Promise<void>;
+}
+/**
+ * Continue one paused Slack agent run from durable conversation state.
+ *
+ * Returns false when the session became stale before generation began.
+ */
+export declare function continueSlackAgentRun(payload: AgentContinueRequest, options?: AgentContinueRunnerOptions): Promise<boolean>;
+/** Resume the first valid paused Slack session for an idle conversation. */
+export declare function resumeAwaitingSlackContinuation(conversationId: string): Promise<boolean>;
+/**
+ * Retry agent continuation when the normal Slack thread lock is briefly busy.
+ *
+ * Returns false when the session became stale before generation began. A busy
+ * lock that is rescheduled still returns true because runnable work remains
+ * durable.
+ */
+export declare function continueSlackAgentRunWithLockRetry(payload: AgentContinueRequest, options?: AgentContinueRunnerOptions): Promise<boolean>;

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

@@ -15,17 +15,17 @@ 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 { TurnContinuationRequest } from "@/chat/services/timeout-resume";
+import type { AgentContinueRequest } from "@/chat/services/agent-continue";
 export interface ReplyExecutorServices {
     contextCompactor: ContextCompactor;
     generateAssistantReply: typeof generateAssistantReplyImpl;
     generateThreadTitle: ConversationMemoryService["generateThreadTitle"];
-    getAwaitingTurnContinuationRequest: (args: {
+    getAwaitingAgentContinueRequest: (args: {
         conversationId: string;
         sessionId: string;
-    }) => Promise<TurnContinuationRequest | undefined>;
+    }) => Promise<AgentContinueRequest | undefined>;
     lookupSlackUser: typeof lookupSlackUser;
-    scheduleTurnTimeoutResume: (request: TurnContinuationRequest) => Promise<void>;
+    scheduleAgentContinue: (request: AgentContinueRequest) => Promise<void>;
 }
 interface ReplyExecutorDeps {
     getSlackAdapter: () => SlackAdapter;

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

@@ -3,7 +3,7 @@ import type { AuthorizationPauseDisposition, AuthorizationPauseKind } from "@/ch
 import type { TurnThinkingSelection } from "@/chat/services/turn-thinking-level";
 import type { AgentTurnUsage } from "@/chat/usage";
 export { buildDeterministicTurnId } from "@/chat/state/turn-id";
-export type RetryableTurnReason = "mcp_auth_resume" | "plugin_auth_resume" | "turn_timeout_resume";
+export type RetryableTurnReason = "mcp_auth_resume" | "plugin_auth_resume" | "agent_continue";
 export interface RetryableTurnMetadata {
     authDisposition?: AuthorizationPauseDisposition;
     authDurationMs?: number;
@@ -16,7 +16,7 @@ export interface RetryableTurnMetadata {
     sessionId?: string;
     sliceId?: number;
 }
-/** Error indicating the turn can be retried (timeout or auth pause). */
+/** Error indicating an agent run can continue later after timeout or auth pause. */
 export declare class RetryableTurnError extends Error {
     readonly code = "retryable_turn";
     readonly metadata?: RetryableTurnMetadata;

package/dist/chat/services/agent-continue.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Durable agent continuation scheduling.
+ *
+ * This module owns the queue handoff used when an agent run pauses at a safe
+ * Pi continuation boundary and needs another execution slice.
+ */
+import type { StateAdapter } from "chat";
+import type { Destination } from "@sentry/junior-plugin-api";
+import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
+export interface AgentContinueRequest {
+    conversationId: string;
+    destination: Destination;
+    expectedVersion: number;
+    sessionId: string;
+}
+export interface ScheduleAgentContinueOptions {
+    nowMs?: number;
+    queue?: ConversationWorkQueue;
+    state?: StateAdapter;
+}
+/** Build the queue request for an awaiting automatic agent continuation. */
+export declare function getAwaitingAgentContinueRequest(args: {
+    conversationId: string;
+    sessionId: string;
+}): Promise<AgentContinueRequest | undefined>;
+/** Schedule durable conversation work to continue a paused agent run. */
+export declare function scheduleAgentContinue(request: AgentContinueRequest, options?: ScheduleAgentContinueOptions): Promise<void>;

package/dist/chat/services/message-actor-identity.d.ts

@@ -1,8 +1,16 @@
 import type { Message } from "chat";
-import { type ActorIdentityInput, type SlackActorProfile } from "@/chat/services/requester-identity";
+import { type Requester, type SlackRequesterProfile } from "@/chat/requester";
+interface MessageAuthorIdentity {
+    email?: string;
+    fullName?: string;
+    userId: string;
+    userName?: string;
+}
+type MessageActorIdentity = Requester | MessageAuthorIdentity;
 /** Preserve runtime-owned identity on Chat SDK messages before persistence. */
-export declare function bindMessageActorIdentity(message: Message, identity: ActorIdentityInput): ActorIdentityInput;
+export declare function bindMessageActorIdentity(message: Message, requester: Requester): Requester;
 /** Read message identity without promoting adapter display fallbacks. */
-export declare function getMessageActorIdentity(message: Message): ActorIdentityInput | undefined;
+export declare function getMessageActorIdentity(message: Message): MessageActorIdentity | undefined;
 /** Attach Slack display fields only after the author id is exact. */
-export declare function ensureSlackMessageActorIdentity(message: Message, lookupSlackUser: (userId: string) => Promise<SlackActorProfile | null | undefined>): Promise<ActorIdentityInput>;
+export declare function ensureSlackMessageActorIdentity(message: Message, teamId: string, lookupSlackUser: (teamId: string, userId: string) => Promise<SlackRequesterProfile | null | undefined>): Promise<Requester>;
+export {};

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

@@ -1,8 +1,9 @@
-import { type AgentTurnSessionRecord, type AgentTurnRequester, type AgentTurnSurface } from "@/chat/state/turn-session";
+import { type AgentTurnSessionRecord, type AgentTurnSurface } from "@/chat/state/turn-session";
+import type { StoredSlackRequester } from "@/chat/requester";
 import type { Destination } from "@sentry/junior-plugin-api";
 import type { PiMessage } from "@/chat/pi/messages";
 import { type AgentTurnUsage } from "@/chat/usage";
-export declare const AGENT_TURN_TIMEOUT_RESUME_MAX_SLICES = 48;
+export declare const AGENT_CONTINUE_MAX_SLICES = 48;
 export interface TurnSessionContext {
     conversationId?: string;
     sessionId?: string;
@@ -33,8 +34,9 @@ export declare function persistRunningSessionRecord(args: {
     messages: PiMessage[];
     loadedSkillNames?: string[];
     logContext: SessionRecordLogContext;
-    requester?: AgentTurnRequester;
+    requester?: StoredSlackRequester;
     surface?: AgentTurnSurface;
+    turnStartMessageIndex?: number;
 }): Promise<boolean>;
 /** Persist a completed turn session record. */
 export declare function persistCompletedSessionRecord(args: {
@@ -48,8 +50,9 @@ export declare function persistCompletedSessionRecord(args: {
     allMessages: PiMessage[];
     loadedSkillNames?: string[];
     logContext: SessionRecordLogContext;
-    requester?: AgentTurnRequester;
+    requester?: StoredSlackRequester;
     surface?: AgentTurnSurface;
+    turnStartMessageIndex?: number;
 }): Promise<void>;
 /**
  * Persist an auth-pause session record. Returns the durable record only when
@@ -67,7 +70,7 @@ export declare function persistAuthPauseSessionRecord(args: {
     loadedSkillNames?: string[];
     errorMessage: string;
     logContext: SessionRecordLogContext;
-    requester?: AgentTurnRequester;
+    requester?: StoredSlackRequester;
     surface?: AgentTurnSurface;
 }): Promise<AgentTurnSessionRecord | undefined>;
 /**
@@ -86,7 +89,7 @@ export declare function persistTimeoutSessionRecord(args: {
     loadedSkillNames?: string[];
     errorMessage: string;
     logContext: SessionRecordLogContext;
-    requester?: AgentTurnRequester;
+    requester?: StoredSlackRequester;
     surface?: AgentTurnSurface;
 }): Promise<AgentTurnSessionRecord | undefined>;
 /**
@@ -104,7 +107,7 @@ export declare function persistYieldSessionRecord(args: {
     loadedSkillNames?: string[];
     errorMessage: string;
     logContext: SessionRecordLogContext;
-    requester?: AgentTurnRequester;
+    requester?: StoredSlackRequester;
     surface?: AgentTurnSurface;
 }): Promise<AgentTurnSessionRecord | undefined>;
 export {};

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

@@ -1,11 +1,11 @@
-import { type ActorIdentityInput } from "@/chat/services/requester-identity";
+import { type Requester } from "@/chat/requester";
 interface SlackUserLookupResult {
     userName?: string;
     fullName?: string;
     email?: string;
 }
 /** Fetch Slack user profile info with in-memory TTL cache to avoid repeated API calls. */
-export declare function lookupSlackUser(userId?: string): Promise<SlackUserLookupResult | null>;
-/** Resolve the canonical Slack actor identity from Slack profile data. */
-export declare function lookupSlackActorIdentity(userId: string): Promise<ActorIdentityInput>;
+export declare function lookupSlackUser(teamId: string, userId?: string): Promise<SlackUserLookupResult | null>;
+/** Resolve the canonical Slack requester from Slack profile data. */
+export declare function lookupSlackRequester(teamId: string, userId: string): Promise<Requester>;
 export {};

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

@@ -5,5 +5,7 @@ export declare function getConnectedStateContext(): Promise<{
     redisStateAdapter?: RedisStateAdapter;
     stateAdapter: StateAdapter;
 }>;
+/** Return the Redis adapter only when the caller is using the default state adapter. */
+export declare function getDefaultRedisStateAdapterFor(adapter: StateAdapter): Promise<RedisStateAdapter | undefined>;
 export declare function getStateAdapter(): StateAdapter;
 export declare function disconnectStateAdapter(): Promise<void>;

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

@@ -1,4 +1,5 @@
-import type { AgentTurnRequester, AgentTurnSurface } from "./turn-session";
+import { type StoredSlackRequester } from "@/chat/requester";
+import type { AgentTurnSurface } from "./turn-session";
 export interface ConversationDetailsRecord {
     conversationId: string;
     /** Generated display title from the LLM. Absent until title has been produced. */
@@ -10,7 +11,7 @@ export interface ConversationDetailsRecord {
     /** Surface on which the conversation was started. */
     originSurface?: AgentTurnSurface;
     /** Requester who initiated the conversation (first turn). */
-    originRequester?: AgentTurnRequester;
+    originRequester?: StoredSlackRequester;
     /** Timestamp of the first turn in the conversation. */
     startedAtMs?: number;
 }
@@ -21,7 +22,7 @@ export interface ConversationDetailsRecord {
 export declare function initConversationContext(conversationId: string, context: {
     channelName?: string;
     originSurface?: AgentTurnSurface;
-    originRequester?: AgentTurnRequester;
+    originRequester?: StoredSlackRequester;
     startedAtMs: number;
 }): Promise<void>;
 /**

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

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import type { PiMessage } from "@/chat/pi/messages";
+import { type StoredSlackRequester } from "@/chat/requester";
 declare const authorizationKindSchema: z.ZodUnion<readonly [z.ZodLiteral<"plugin">, z.ZodLiteral<"mcp">]>;
 declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
@@ -11,6 +12,14 @@ declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         [x: string]: unknown;
         role: string;
     }>>;
+    requester: z.ZodOptional<z.ZodObject<{
+        email: z.ZodOptional<z.ZodString>;
+        fullName: z.ZodOptional<z.ZodString>;
+        platform: z.ZodOptional<z.ZodLiteral<"slack">>;
+        slackUserId: z.ZodOptional<z.ZodString>;
+        slackUserName: z.ZodOptional<z.ZodString>;
+        teamId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
 }, z.core.$strip>, z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     type: z.ZodLiteral<"projection_reset">;
@@ -21,6 +30,26 @@ declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         [x: string]: unknown;
         role: string;
     }>>>;
+    requester: z.ZodOptional<z.ZodObject<{
+        email: z.ZodOptional<z.ZodString>;
+        fullName: z.ZodOptional<z.ZodString>;
+        platform: z.ZodOptional<z.ZodLiteral<"slack">>;
+        slackUserId: z.ZodOptional<z.ZodString>;
+        slackUserName: z.ZodOptional<z.ZodString>;
+        teamId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strip>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"requester_recorded">;
+    sessionId: z.ZodDefault<z.ZodString>;
+    requester: z.ZodObject<{
+        email: z.ZodOptional<z.ZodString>;
+        fullName: z.ZodOptional<z.ZodString>;
+        platform: z.ZodOptional<z.ZodLiteral<"slack">>;
+        slackUserId: z.ZodOptional<z.ZodString>;
+        slackUserName: z.ZodOptional<z.ZodString>;
+        teamId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
 }, z.core.$strip>, z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     type: z.ZodLiteral<"mcp_provider_connected">;
@@ -46,6 +75,7 @@ declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     requesterId: z.ZodString;
     authorizationId: z.ZodString;
 }, z.core.$strip>], "type">;
+/** Requester identity stored with turn-start messages for durable continuation. */
 export type SessionLogEntry = z.infer<typeof sessionLogEntrySchema>;
 export type AuthorizationKind = z.infer<typeof authorizationKindSchema>;
 interface Scope {
@@ -60,6 +90,10 @@ export interface SessionLogStore {
     append(args: AppendArgs): Promise<void>;
     read(scope: Scope): Promise<SessionLogEntry[]>;
 }
+export interface SessionProjection {
+    messages: PiMessage[];
+    requester?: StoredSlackRequester;
+}
 /** Load the committed Pi-message projection for a conversation. */
 export declare function loadMessages(args: Scope & {
     store?: SessionLogStore;
@@ -71,6 +105,14 @@ export declare function loadProjection(args: Scope & {
     store?: SessionLogStore;
     sessionId?: string;
 }): Promise<PiMessage[]>;
+/**
+ * Load the Pi-message projection and derived requester identity in one read.
+ * Used at continuation boundaries to avoid a second log scan.
+ */
+export declare function loadProjectionWithRequester(args: Scope & {
+    store?: SessionLogStore;
+    sessionId?: string;
+}): Promise<SessionProjection>;
 /** Load MCP providers that were durably connected in this conversation. */
 export declare function loadConnectedMcpProviders(args: Scope & {
     store?: SessionLogStore;
@@ -111,6 +153,7 @@ export declare function commitMessages(args: Scope & {
     store?: SessionLogStore;
     messages: PiMessage[];
     ttlMs: number;
+    requester?: StoredSlackRequester;
 }): Promise<{
     sessionId: string;
 }>;

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

@@ -1,15 +1,10 @@
 import type { Destination } from "@sentry/junior-plugin-api";
 import type { PiMessage } from "@/chat/pi/messages";
+import { type StoredSlackRequester } from "@/chat/requester";
 import type { AgentTurnUsage } from "@/chat/usage";
 export type AgentTurnSessionStatus = "running" | "awaiting_resume" | "completed" | "failed" | "abandoned";
 export type AgentTurnSurface = "slack" | "api" | "scheduler" | "internal";
 export type AgentTurnResumeReason = "timeout" | "auth" | "yield";
-export interface AgentTurnRequester {
-    email?: string;
-    fullName?: string;
-    slackUserId?: string;
-    slackUserName?: string;
-}
 export interface AgentTurnSessionRecord {
     channelName?: string;
     version: number;
@@ -21,7 +16,7 @@ export interface AgentTurnSessionRecord {
     lastProgressAtMs: number;
     loadedSkillNames?: string[];
     piMessages: PiMessage[];
-    requester?: AgentTurnRequester;
+    requester?: StoredSlackRequester;
     resumeReason?: AgentTurnResumeReason;
     resumedFromSliceId?: number;
     sessionId: string;
@@ -30,9 +25,10 @@ export interface AgentTurnSessionRecord {
     state: AgentTurnSessionStatus;
     surface?: AgentTurnSurface;
     traceId?: string;
+    turnStartMessageIndex?: number;
     updatedAtMs: number;
 }
-export type AgentTurnSessionSummary = Omit<AgentTurnSessionRecord, "errorMessage" | "piMessages">;
+export type AgentTurnSessionSummary = Omit<AgentTurnSessionRecord, "errorMessage" | "piMessages" | "turnStartMessageIndex">;
 /** Read a materialized turn session record for resume and history loading. */
 export declare function getAgentTurnSessionRecord(conversationId: string, sessionId: string): Promise<AgentTurnSessionRecord | undefined>;
 /** Commit stable Pi session state and advance the turn session record. */
@@ -49,11 +45,12 @@ export declare function upsertAgentTurnSessionRecord(args: {
     state: AgentTurnSessionStatus;
     surface?: AgentTurnSurface;
     piMessages: PiMessage[];
-    requester?: AgentTurnRequester;
+    requester?: StoredSlackRequester;
     resumeReason?: AgentTurnResumeReason;
     errorMessage?: string;
     resumedFromSliceId?: number;
     traceId?: string;
+    turnStartMessageIndex?: number;
     ttlMs?: number;
 }): Promise<AgentTurnSessionRecord>;
 /** Record turn-session metadata without storing conversation messages. */
@@ -65,7 +62,7 @@ export declare function recordAgentTurnSessionSummary(args: {
     destination?: Destination;
     lastProgressAtMs?: number;
     loadedSkillNames?: string[];
-    requester?: AgentTurnRequester;
+    requester?: StoredSlackRequester;
     resumeReason?: AgentTurnResumeReason;
     sessionId: string;
     sliceId: number;

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

@@ -3,7 +3,7 @@ export interface ConversationQueueMessage {
     conversationId: string;
     destination: Destination;
 }
-export type ConversationQueueMessageRejectReason = "destination_mismatch" | "expired" | "malformed" | "signature_mismatch" | "unauthorized";
+export type ConversationQueueMessageRejectReason = "destination_mismatch" | "expired" | "malformed" | "signature_mismatch";
 export declare class ConversationQueueMessageRejectedError extends Error {
     conversationId?: string;
     reason: ConversationQueueMessageRejectReason;

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

@@ -1,10 +1,10 @@
 import type { SlackAdapter } from "@chat-adapter/slack";
 import { Message, ThreadImpl, type SerializedMessage, type SerializedThread, type StateAdapter } from "chat";
 import type { SlackTurnRuntime } from "@/chat/runtime/slack-runtime";
-import type { InboundMessageRecord } from "@/chat/task-execution/store";
+import type { InboundMessage } from "@/chat/task-execution/store";
 import type { ConversationWorkerContext, ConversationWorkerResult } from "@/chat/task-execution/worker";
 import { type SlackInstallationContext } from "@/chat/slack/adapter-context";
-import { type SlackActorProfile } from "@/chat/services/requester-identity";
+import { type SlackRequesterProfile } from "@/chat/requester";
 export type SlackConversationRoute = "mention" | "subscribed";
 export interface SlackConversationMessageMetadata {
     [key: string]: unknown;
@@ -16,8 +16,8 @@ export interface SlackConversationMessageMetadata {
 }
 export interface CreateSlackConversationWorkerOptions {
     getSlackAdapter: () => SlackAdapter;
-    lookupSlackUser?: (userId: string) => Promise<SlackActorProfile | null | undefined>;
-    resumeAwaitingContinuation?: (conversationId: string) => Promise<boolean>;
+    lookupSlackUser?: (teamId: string, userId: string) => Promise<SlackRequesterProfile | null | undefined>;
+    resumeAwaitingContinuation: (conversationId: string) => Promise<boolean>;
     runtime: Pick<SlackTurnRuntime<unknown>, "handleNewMention" | "handleSubscribedMessage">;
     state?: StateAdapter;
 }
@@ -31,4 +31,4 @@ export declare function buildSlackInboundMessage(args: {
     receivedAtMs: number;
     route: SlackConversationRoute;
     thread: ThreadImpl;
-}): InboundMessageRecord;
+}): InboundMessage;