@sentry/junior 0.91.0 → 0.92.1

package/dist/chat/slack/tools/list/update-item.d.ts

@@ -1,3 +1,48 @@
 import type { ToolState } from "@/chat/tools/types";
 /** Create a tool that updates an item in the active Slack list. */
-export declare function createSlackListUpdateItemTool(state: ToolState): import("../../../tools/definition").AnyToolDefinition;
+export declare function createSlackListUpdateItemTool(state: ToolState): Omit<import("../../../tools/definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("../../../tools/definition").JsonSchemaObject;
+    outputSchema: import("../../../tools/definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        item_id: string;
+        completed: boolean;
+        title?: string | undefined;
+    } | {
+        item_id: string;
+        title: string;
+        completed?: boolean | undefined;
+    };
+    execute?: ((input: unknown, options: import("../../../tools/definition").ToolExecuteOptions) => {
+        [x: string]: unknown;
+        ok: boolean;
+        status: "error" | "success";
+        target?: string | undefined;
+        data?: unknown;
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+        error?: string | {
+            kind: string;
+            message: string;
+            retryable?: boolean | undefined;
+        } | undefined;
+    } | Promise<{
+        [x: string]: unknown;
+        ok: boolean;
+        status: "error" | "success";
+        target?: string | undefined;
+        data?: unknown;
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+        error?: string | {
+            kind: string;
+            message: string;
+            retryable?: boolean | undefined;
+        } | undefined;
+    }>) | undefined;
+};

package/dist/chat/slack/tools/message-add-reaction.d.ts

@@ -1,4 +1,43 @@
 import type { SlackToolContext } from "@/chat/slack/tools/context";
 import type { ToolState } from "@/chat/tools/types";
 /** Create the tool that reacts to the current inbound Slack message. */
-export declare function createSlackMessageAddReactionTool(context: SlackToolContext, state: ToolState): import("../../tools/definition").AnyToolDefinition;
+export declare function createSlackMessageAddReactionTool(context: SlackToolContext, state: ToolState): Omit<import("../../tools/definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("../../tools/definition").JsonSchemaObject;
+    outputSchema: import("../../tools/definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        emoji: string;
+    };
+    execute?: ((input: unknown, options: import("../../tools/definition").ToolExecuteOptions) => {
+        [x: string]: unknown;
+        ok: boolean;
+        status: "error" | "success";
+        target?: string | undefined;
+        data?: unknown;
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+        error?: string | {
+            kind: string;
+            message: string;
+            retryable?: boolean | undefined;
+        } | undefined;
+    } | Promise<{
+        [x: string]: unknown;
+        ok: boolean;
+        status: "error" | "success";
+        target?: string | undefined;
+        data?: unknown;
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+        error?: string | {
+            kind: string;
+            message: string;
+            retryable?: boolean | undefined;
+        } | undefined;
+    }>) | undefined;
+};

package/dist/chat/slack/tools/send-message.d.ts

@@ -8,4 +8,48 @@ export type MaterializeMessageFile = (input: {
     mimeType?: string;
 }) => Promise<SandboxFileUpload>;
 /** Create the Slack side-effect tool for active-conversation text and file messages. */
-export declare function createSendMessageTool(context: SlackToolContext, state: ToolState, materializeFile: MaterializeMessageFile): import("../../tools/definition").AnyToolDefinition;
+export declare function createSendMessageTool(context: SlackToolContext, state: ToolState, materializeFile: MaterializeMessageFile): Omit<import("../../tools/definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("../../tools/definition").JsonSchemaObject;
+    outputSchema: import("../../tools/definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        text?: string | null | undefined;
+        files?: {
+            path: string;
+            filename?: string | null | undefined;
+            mimeType?: string | null | undefined;
+        }[] | null | undefined;
+    };
+    execute?: ((input: unknown, options: import("../../tools/definition").ToolExecuteOptions) => {
+        [x: string]: unknown;
+        ok: boolean;
+        status: "error" | "success";
+        target?: string | undefined;
+        data?: unknown;
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+        error?: string | {
+            kind: string;
+            message: string;
+            retryable?: boolean | undefined;
+        } | undefined;
+    } | Promise<{
+        [x: string]: unknown;
+        ok: boolean;
+        status: "error" | "success";
+        target?: string | undefined;
+        data?: unknown;
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+        error?: string | {
+            kind: string;
+            message: string;
+            retryable?: boolean | undefined;
+        } | undefined;
+    }>) | undefined;
+};

package/dist/chat/slack/tools/thread-read.d.ts

@@ -3,4 +3,47 @@ import type { SlackToolContext } from "@/chat/slack/tools/context";
 /** Create a tool that reads a Slack thread from a shared message URL or explicit coordinates. */
 export declare function createSlackThreadReadTool(context: SlackToolContext, deps?: {
     visibilityStore?: DestinationVisibilityReader;
-}): import("../../tools/definition").AnyToolDefinition;
+}): Omit<import("../../tools/definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("../../tools/definition").JsonSchemaObject;
+    outputSchema: import("../../tools/definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        url?: string | undefined;
+        channel_id?: string | undefined;
+        ts?: string | undefined;
+        limit?: number | undefined;
+        max_pages?: number | undefined;
+    };
+    execute?: ((input: unknown, options: import("../../tools/definition").ToolExecuteOptions) => {
+        [x: string]: unknown;
+        ok: boolean;
+        status: "error" | "success";
+        target?: string | undefined;
+        data?: unknown;
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+        error?: string | {
+            kind: string;
+            message: string;
+            retryable?: boolean | undefined;
+        } | undefined;
+    } | Promise<{
+        [x: string]: unknown;
+        ok: boolean;
+        status: "error" | "success";
+        target?: string | undefined;
+        data?: unknown;
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+        error?: string | {
+            kind: string;
+            message: string;
+            retryable?: boolean | undefined;
+        } | undefined;
+    }>) | undefined;
+};

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

@@ -1,2 +1,46 @@
 /** Create the tool that resolves Slack users by ID, handle, or email. */
-export declare function createSlackUserLookupTool(): import("../../tools/definition").AnyToolDefinition;
+export declare function createSlackUserLookupTool(): Omit<import("../../tools/definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("../../tools/definition").JsonSchemaObject;
+    outputSchema: import("../../tools/definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        user_id?: string | undefined;
+        email?: string | undefined;
+        query?: string | undefined;
+        limit?: number | undefined;
+        max_pages?: number | undefined;
+        include_bots?: boolean | undefined;
+    };
+    execute?: ((input: unknown, options: import("../../tools/definition").ToolExecuteOptions) => {
+        [x: string]: unknown;
+        ok: boolean;
+        status: "error" | "success";
+        target?: string | undefined;
+        data?: unknown;
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+        error?: string | {
+            kind: string;
+            message: string;
+            retryable?: boolean | undefined;
+        } | undefined;
+    } | Promise<{
+        [x: string]: unknown;
+        ok: boolean;
+        status: "error" | "success";
+        target?: string | undefined;
+        data?: unknown;
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+        error?: string | {
+            kind: string;
+            message: string;
+            retryable?: boolean | undefined;
+        } | undefined;
+    }>) | undefined;
+};

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

@@ -1,4 +1,4 @@
-import { type SlackRequester } from "@/chat/requester";
+import { type SlackActor } from "@/chat/actor";
 interface SlackUserLookupResult {
     userName?: string;
     fullName?: string;
@@ -6,6 +6,6 @@ interface SlackUserLookupResult {
 }
 /** Fetch Slack user profile info with in-memory TTL cache to avoid repeated API calls. */
 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<SlackRequester>;
+/** Resolve the canonical Slack actor from Slack profile data. */
+export declare function lookupSlackActor(teamId: string, userId: string): Promise<SlackActor>;
 export {};

package/dist/chat/slack/vision-context.d.ts

@@ -38,7 +38,7 @@ export interface VisionContextService {
     hydrateConversationVisionContext: (conversation: ThreadConversationState, context: {
         threadId?: string;
         channelId?: string;
-        requesterId?: string;
+        actorId?: string;
         runId?: string;
         threadTs?: string;
     }) => Promise<void>;
@@ -46,7 +46,7 @@ export interface VisionContextService {
 }
 interface ResolveUserAttachmentsContext {
     threadId?: string;
-    requesterId?: string;
+    actorId?: string;
     channelId?: string;
     runId?: string;
     conversation?: ThreadConversationState;

package/dist/chat/sql/schema.d.ts

@@ -175,23 +175,6 @@ export declare const juniorSqlSchema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
-            requesterIdentityId: import("drizzle-orm/pg-core").PgColumn<{
-                name: "requester_identity_id";
-                tableName: "junior_conversations";
-                dataType: "string";
-                columnType: "PgText";
-                data: string;
-                driverParam: string;
-                notNull: false;
-                hasDefault: false;
-                isPrimaryKey: false;
-                isAutoincrement: false;
-                hasRuntimeDefault: false;
-                enumValues: [string, ...string[]];
-                baseColumn: never;
-                identity: undefined;
-                generated: undefined;
-            }, {}, {}>;
             creatorIdentityId: import("drizzle-orm/pg-core").PgColumn<{
                 name: "creator_identity_id";
                 tableName: "junior_conversations";
@@ -226,8 +209,8 @@ export declare const juniorSqlSchema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
-            requester: import("drizzle-orm/pg-core").PgColumn<{
-                name: "requester_json";
+            actor: import("drizzle-orm/pg-core").PgColumn<{
+                name: "actor_json";
                 tableName: "junior_conversations";
                 dataType: "json";
                 columnType: "PgJsonb";

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

@@ -1,4 +1,4 @@
-import { type StoredSlackRequester } from "@/chat/requester";
+import { type StoredSlackActor } from "@/chat/actor";
 import type { AgentTurnSurface } from "./turn-session";
 export interface ConversationDetailsRecord {
     conversationId: string;
@@ -10,8 +10,8 @@ export interface ConversationDetailsRecord {
     channelName?: string;
     /** Surface on which the conversation was started. */
     originSurface?: AgentTurnSurface;
-    /** Requester who initiated the conversation (first turn). */
-    originRequester?: StoredSlackRequester;
+    /** Actor who initiated the conversation (first turn). */
+    originActor?: StoredSlackActor;
     /** Timestamp of the first turn in the conversation. */
     startedAtMs?: number;
 }
@@ -22,7 +22,7 @@ export interface ConversationDetailsRecord {
 export declare function initConversationContext(conversationId: string, context: {
     channelName?: string;
     originSurface?: AgentTurnSurface;
-    originRequester?: StoredSlackRequester;
+    originActor?: StoredSlackActor;
     startedAtMs: number;
 }): Promise<void>;
 /**

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

@@ -44,7 +44,7 @@ export interface ConversationPendingAuthState {
     kind: AuthorizationPauseKind;
     linkSentAtMs: number;
     provider: string;
-    requesterId: string;
+    actorId: string;
     scope?: string;
     sessionId: string;
 }

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

@@ -1,6 +1,32 @@
 import { z } from "zod";
+import { type Actor } from "@sentry/junior-plugin-api";
 import { type PiMessage } from "@/chat/pi/messages";
-import { type StoredSlackRequester } from "@/chat/requester";
+import { type StoredSlackActor } from "@/chat/actor";
+declare const piMessageAuthoritySchema: z.ZodUnion<readonly [z.ZodLiteral<"instruction">, z.ZodLiteral<"context">]>;
+declare const piMessageProvenanceSchema: z.ZodObject<{
+    authority: z.ZodUnion<readonly [z.ZodLiteral<"instruction">, z.ZodLiteral<"context">]>;
+    actor: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        email: z.ZodOptional<z.ZodString>;
+        fullName: z.ZodOptional<z.ZodString>;
+        userId: z.ZodString;
+        userName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"local">;
+        email: z.ZodOptional<z.ZodString>;
+        fullName: z.ZodOptional<z.ZodString>;
+        userId: z.ZodString;
+        userName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"system">;
+        name: z.ZodString;
+    }, z.core.$strict>], "platform">>;
+}, z.core.$strict>;
+/** Whether a user-role Pi message is a durable instruction or ambient context. */
+export type PiMessageAuthority = z.output<typeof piMessageAuthoritySchema>;
+/** Per-message record of the actor a Pi message came from and its authority weight. */
+export type PiMessageProvenance = z.output<typeof piMessageProvenanceSchema>;
 declare const authorizationKindSchema: z.ZodUnion<readonly [z.ZodLiteral<"plugin">, z.ZodLiteral<"mcp">]>;
 declare const transcriptRefSchema: z.ZodObject<{
     type: z.ZodLiteral<"advisor_session">;
@@ -8,16 +34,36 @@ declare const transcriptRefSchema: z.ZodObject<{
     key: z.ZodString;
 }, z.core.$strip>;
 declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
+    schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
     type: z.ZodLiteral<"pi_message">;
     sessionId: z.ZodDefault<z.ZodString>;
     message: z.ZodPipe<z.ZodObject<{
         role: z.ZodString;
-    }, z.core.$loose>, z.ZodTransform<import("@earendil-works/pi-ai").UserMessage | import("@earendil-works/pi-ai").AssistantMessage | import("@earendil-works/pi-ai").ToolResultMessage<any> | import("@earendil-works/pi-agent-core").CustomMessage<unknown> | import("@earendil-works/pi-agent-core").BashExecutionMessage | import("@earendil-works/pi-agent-core").BranchSummaryMessage | import("@earendil-works/pi-agent-core").CompactionSummaryMessage, {
+    }, z.core.$loose>, z.ZodTransform<import("@earendil-works/pi-ai").AssistantMessage | import("@earendil-works/pi-ai").UserMessage | import("@earendil-works/pi-ai").ToolResultMessage<any> | import("@earendil-works/pi-agent-core").CustomMessage<unknown> | import("@earendil-works/pi-agent-core").BashExecutionMessage | import("@earendil-works/pi-agent-core").BranchSummaryMessage | import("@earendil-works/pi-agent-core").CompactionSummaryMessage, {
         [x: string]: unknown;
         role: string;
     }>>;
-    requester: z.ZodOptional<z.ZodObject<{
+    provenance: z.ZodOptional<z.ZodObject<{
+        authority: z.ZodUnion<readonly [z.ZodLiteral<"instruction">, z.ZodLiteral<"context">]>;
+        actor: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            platform: z.ZodLiteral<"slack">;
+            teamId: z.ZodString;
+            email: z.ZodOptional<z.ZodString>;
+            fullName: z.ZodOptional<z.ZodString>;
+            userId: z.ZodString;
+            userName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            platform: z.ZodLiteral<"local">;
+            email: z.ZodOptional<z.ZodString>;
+            fullName: z.ZodOptional<z.ZodString>;
+            userId: z.ZodString;
+            userName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            platform: z.ZodLiteral<"system">;
+            name: z.ZodString;
+        }, z.core.$strict>], "platform">>;
+    }, z.core.$strict>>;
+    actor: z.ZodOptional<z.ZodObject<{
         email: z.ZodOptional<z.ZodString>;
         fullName: z.ZodOptional<z.ZodString>;
         platform: z.ZodOptional<z.ZodLiteral<"slack">>;
@@ -26,16 +72,36 @@ declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         teamId: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
 }, z.core.$strip>, z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
+    schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
     type: z.ZodLiteral<"projection_reset">;
     sessionId: z.ZodDefault<z.ZodString>;
     messages: z.ZodArray<z.ZodPipe<z.ZodObject<{
         role: z.ZodString;
-    }, z.core.$loose>, z.ZodTransform<import("@earendil-works/pi-ai").UserMessage | import("@earendil-works/pi-ai").AssistantMessage | import("@earendil-works/pi-ai").ToolResultMessage<any> | import("@earendil-works/pi-agent-core").CustomMessage<unknown> | import("@earendil-works/pi-agent-core").BashExecutionMessage | import("@earendil-works/pi-agent-core").BranchSummaryMessage | import("@earendil-works/pi-agent-core").CompactionSummaryMessage, {
+    }, z.core.$loose>, z.ZodTransform<import("@earendil-works/pi-ai").AssistantMessage | import("@earendil-works/pi-ai").UserMessage | import("@earendil-works/pi-ai").ToolResultMessage<any> | import("@earendil-works/pi-agent-core").CustomMessage<unknown> | import("@earendil-works/pi-agent-core").BashExecutionMessage | import("@earendil-works/pi-agent-core").BranchSummaryMessage | import("@earendil-works/pi-agent-core").CompactionSummaryMessage, {
         [x: string]: unknown;
         role: string;
     }>>>;
-    requester: z.ZodOptional<z.ZodObject<{
+    provenance: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        authority: z.ZodUnion<readonly [z.ZodLiteral<"instruction">, z.ZodLiteral<"context">]>;
+        actor: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            platform: z.ZodLiteral<"slack">;
+            teamId: z.ZodString;
+            email: z.ZodOptional<z.ZodString>;
+            fullName: z.ZodOptional<z.ZodString>;
+            userId: z.ZodString;
+            userName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            platform: z.ZodLiteral<"local">;
+            email: z.ZodOptional<z.ZodString>;
+            fullName: z.ZodOptional<z.ZodString>;
+            userId: z.ZodString;
+            userName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            platform: z.ZodLiteral<"system">;
+            name: z.ZodString;
+        }, z.core.$strict>], "platform">>;
+    }, z.core.$strict>>>;
+    actor: z.ZodOptional<z.ZodObject<{
         email: z.ZodOptional<z.ZodString>;
         fullName: z.ZodOptional<z.ZodString>;
         platform: z.ZodOptional<z.ZodLiteral<"slack">>;
@@ -44,10 +110,10 @@ declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         teamId: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
 }, z.core.$strip>, z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
-    type: z.ZodLiteral<"requester_recorded">;
+    schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+    type: z.ZodLiteral<"actor_recorded">;
     sessionId: z.ZodDefault<z.ZodString>;
-    requester: z.ZodObject<{
+    actor: z.ZodObject<{
         email: z.ZodOptional<z.ZodString>;
         fullName: z.ZodOptional<z.ZodString>;
         platform: z.ZodOptional<z.ZodLiteral<"slack">>;
@@ -56,31 +122,31 @@ declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         teamId: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
 }, z.core.$strip>, z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
+    schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
     type: z.ZodLiteral<"mcp_provider_connected">;
     sessionId: z.ZodDefault<z.ZodString>;
     provider: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
+    schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
     type: z.ZodLiteral<"authorization_requested">;
     sessionId: z.ZodDefault<z.ZodString>;
     createdAtMs: z.ZodNumber;
     kind: z.ZodUnion<readonly [z.ZodLiteral<"plugin">, z.ZodLiteral<"mcp">]>;
     provider: z.ZodString;
-    requesterId: z.ZodString;
+    actorId: z.ZodString;
     authorizationId: z.ZodString;
     delivery: z.ZodUnion<readonly [z.ZodLiteral<"private_link_sent">, z.ZodLiteral<"private_link_reused">]>;
 }, z.core.$strip>, z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
+    schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
     type: z.ZodLiteral<"authorization_completed">;
     sessionId: z.ZodDefault<z.ZodString>;
     createdAtMs: z.ZodNumber;
     kind: z.ZodUnion<readonly [z.ZodLiteral<"plugin">, z.ZodLiteral<"mcp">]>;
     provider: z.ZodString;
-    requesterId: z.ZodString;
+    actorId: z.ZodString;
     authorizationId: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
+    schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
     type: z.ZodLiteral<"tool_execution_started">;
     sessionId: z.ZodDefault<z.ZodString>;
     createdAtMs: z.ZodNumber;
@@ -88,7 +154,7 @@ declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     toolName: z.ZodString;
     args: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>, z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
+    schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
     type: z.ZodLiteral<"subagent_started">;
     sessionId: z.ZodDefault<z.ZodString>;
     subagentInvocationId: z.ZodString;
@@ -104,7 +170,7 @@ declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     historyMode: z.ZodLiteral<"shared">;
     createdAtMs: z.ZodNumber;
 }, z.core.$strip>, z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
+    schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
     type: z.ZodLiteral<"subagent_ended">;
     sessionId: z.ZodDefault<z.ZodString>;
     subagentInvocationId: z.ZodString;
@@ -114,7 +180,7 @@ declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     transcriptStartMessageIndex: z.ZodOptional<z.ZodNumber>;
     createdAtMs: z.ZodNumber;
 }, z.core.$strip>], "type">;
-/** Requester identity stored with turn-start messages for durable continuation. */
+/** Actor identity stored with turn-start messages for durable continuation. */
 export type SessionLogEntry = z.infer<typeof sessionLogEntrySchema>;
 export type AuthorizationKind = z.infer<typeof authorizationKindSchema>;
 export type TranscriptRef = z.infer<typeof transcriptRefSchema>;
@@ -137,10 +203,21 @@ export interface SessionLogStore {
     append(args: AppendArgs): Promise<void>;
     read(scope: Scope): Promise<SessionLogEntry[]>;
 }
+/** Aligned Pi-message projection: `provenance[i]` describes `messages[i]`. */
 export interface SessionProjection {
     messages: PiMessage[];
-    requester?: StoredSlackRequester;
+    provenance: PiMessageProvenance[];
 }
+/**
+ * All distinct actors annotated on instruction-authority messages, in
+ * first-seen order — the run's actors. This is attribution, never
+ * authority: it exists so provenance consumers know which actors
+ * contributed instructions to a run. It must never feed credential
+ * issuance, credential-subject selection, or scope ownership.
+ * Unattributable instructions (no resolvable actor) never join;
+ * distinctness is by identity ids only, never display fields.
+ */
+export declare function instructionActors(provenance: PiMessageProvenance[]): Actor[];
 /** Load chronological host-only runtime activity entries for reporting. */
 export declare function loadActivityEntries(args: Scope & {
     store?: SessionLogStore;
@@ -152,19 +229,38 @@ export declare function loadMessages(args: Scope & {
     messageCount: number;
     sessionId?: string;
 }): Promise<PiMessage[] | undefined>;
+/** Load the committed Pi-message projection with aligned per-message provenance. */
+export declare function loadMessagesWithProvenance(args: Scope & {
+    store?: SessionLogStore;
+    messageCount: number;
+    sessionId?: string;
+}): Promise<SessionProjection | undefined>;
 /** Load the full current Pi-message projection for a conversation. */
 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.
+ * Load the Pi-message projection with aligned per-message provenance in one
+ * read. Used at continuation boundaries to avoid a second log scan.
  */
-export declare function loadProjectionWithRequester(args: Scope & {
+export declare function loadProjectionWithProvenance(args: Scope & {
     store?: SessionLogStore;
     sessionId?: string;
 }): Promise<SessionProjection>;
+/**
+ * Load the projection with the latest instruction actor as a stored Slack
+ * actor. Retained for callers that still key on a single latest actor; it
+ * derives the actor from per-message provenance rather than a latest-wins
+ * field.
+ */
+export declare function loadProjectionWithActor(args: Scope & {
+    store?: SessionLogStore;
+    sessionId?: string;
+}): Promise<{
+    messages: PiMessage[];
+    actor?: StoredSlackActor;
+}>;
 /** Load MCP providers that were durably connected in this conversation. */
 export declare function loadConnectedMcpProviders(args: Scope & {
     store?: SessionLogStore;
@@ -180,7 +276,7 @@ export declare function recordAuthorizationRequested(args: Scope & {
     store?: SessionLogStore;
     kind: AuthorizationKind;
     provider: string;
-    requesterId: string;
+    actorId: string;
     authorizationId: string;
     delivery: "private_link_sent" | "private_link_reused";
     ttlMs: number;
@@ -190,7 +286,7 @@ export declare function recordAuthorizationCompleted(args: Scope & {
     store?: SessionLogStore;
     kind: AuthorizationKind;
     provider: string;
-    requesterId: string;
+    actorId: string;
     authorizationId: string;
     ttlMs: number;
 }): Promise<void>;
@@ -241,8 +337,26 @@ export declare function commitMessages(args: Scope & {
     store?: SessionLogStore;
     messages: PiMessage[];
     ttlMs: number;
-    requester?: StoredSlackRequester;
+    /** Explicit per-message provenance aligned one-to-one with `messages`. */
+    provenance?: PiMessageProvenance[];
+    /** Explicit provenance for the trailing newly committed messages. */
+    trailingMessageProvenance?: PiMessageProvenance[];
+    /** Default applied to the last new user message when no explicit array. */
+    newMessageProvenance?: PiMessageProvenance;
 }): Promise<{
     sessionId: string;
+    provenance: PiMessageProvenance[];
 }>;
+/** Build an instruction-provenance record for the given actor. */
+export declare function instructionProvenanceFor(actor: Actor | undefined): PiMessageProvenance;
+/** Unattributed ambient-context provenance for non-instruction Pi messages. */
+export declare const contextProvenance: PiMessageProvenance;
+/**
+ * Parse durably-stored message provenance, failing closed on misalignment.
+ *
+ * A missing field is a legacy record: it materializes as unauthored context of
+ * the expected length. A present-but-malformed or wrong-length value returns
+ * undefined so callers reject the record rather than zip a mismatched array.
+ */
+export declare function parseStoredMessageProvenance(value: unknown, expectedLength: number): PiMessageProvenance[] | undefined;
 export {};