@sentry/junior 0.96.0 → 0.97.1

package/dist/build/virtual-config.d.ts

@@ -8,7 +8,7 @@ export interface RuntimePluginModule {
 }
 /** Render the virtual config module consumed by createApp(). */
 export declare function renderVirtualConfig(options: {
-    dashboard?: Omit<JuniorDashboardOptions, "reporting">;
+    dashboard?: JuniorDashboardOptions;
     plugins?: PluginCatalogConfig;
     pluginModule?: RuntimePluginModule;
     pluginRuntimeRegistrations?: string[];
@@ -19,5 +19,5 @@ export declare function injectVirtualConfig(nitro: Nitro, options?: {
     pluginModule?: RuntimePluginModule;
     plugins?: PluginCatalogConfig;
     pluginRuntimeRegistrations?: string[];
-    dashboard?: Omit<JuniorDashboardOptions, "reporting">;
+    dashboard?: JuniorDashboardOptions;
 }): void;

package/dist/{catalog-runtime-MSMAYYIK.js → catalog-runtime-PFHVMHDR.js}

@@ -1,11 +1,12 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-L7CDEIVJ.js";
+} from "./chunk-LMJPRYHP.js";
 import "./chunk-I35CTGPO.js";
 import "./chunk-OB42YVAE.js";
 import "./chunk-6GWA276C.js";
-import "./chunk-6APU57E6.js";
+import "./chunk-B3IT5END.js";
 import "./chunk-7FBGKXPE.js";
+import "./chunk-3V7OFJZC.js";
 import "./chunk-MLKGABMK.js";
 export {
   pluginCatalogRuntime

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

@@ -24,8 +24,8 @@ interface ResumeStateArgs {
     destination: Destination;
     durability: AgentRunDurability;
     getLoadedSkillNames: () => string[];
+    getModelId: () => string;
     logContext: SessionRecordLogContext;
-    modelId: string;
     getReasoningLevel: () => string | undefined;
     recordActiveMcpProviders: () => Promise<void>;
     actor?: Actor;
@@ -47,6 +47,8 @@ export declare function createResumeState(args: ResumeStateArgs): {
     readonly cooperativeYieldError: CooperativeTurnYieldError | undefined;
     setTurnStartMessageIndex(index: number | undefined): void;
     setBeforeMessageCount(count: number): void;
+    /** Adopt an already committed epoch replacement as every resume baseline. */
+    adoptCommittedBoundary(messages: PiMessage[]): void;
     captureResumeSnapshot(messages: PiMessage[]): void;
     getResumeSnapshot(currentMessages: PiMessage[]): PiMessage[];
     markTimedOut(): void;

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

@@ -4,7 +4,7 @@
  * Builds everything the agent can act through for one run slice: the sandbox
  * executor and lazy workspace, MCP and plugin auth orchestration, MCP
  * provider restoration from durable history, and the Pi-facing tool surfaces
- * (agent tools plus the advisor's tool view). Auth pauses raised while
+ * (main-agent tools plus runtime control tools). Auth pauses raised while
  * restoring providers are thrown here so the run parks before prompting.
  */
 import type { AgentTool } from "@earendil-works/pi-agent-core";
@@ -49,6 +49,7 @@ interface ToolWiringArgs {
     preAgentPromptMessages: () => PiMessage[];
     priorPiMessages: PiMessage[] | undefined;
     recordConnectedMcpProvider: (provider: string) => Promise<void>;
+    requestHandoff?: ToolRuntimeContext["handoff"];
     resume: ResumeState;
     routing: AgentRunRouting;
     sessionConversationId?: string;

package/dist/chat/config.d.ts

@@ -1,25 +1,19 @@
-declare const ADVISOR_THINKING_LEVELS: readonly ["minimal", "low", "medium", "high", "xhigh"];
-export type AdvisorThinkingLevel = (typeof ADVISOR_THINKING_LEVELS)[number];
 /**
  * Buffer between the Vercel function timeout and the agent turn timeout so
  * Junior can abort, persist, and schedule continuation before host teardown.
  */
 export declare const FUNCTION_TIMEOUT_BUFFER_SECONDS = 20;
 export interface BotConfig {
-    advisor: AdvisorConfig;
     embeddingModelId: string;
     fastModelId: string;
     loadingMessages: string[];
     modelId: string;
+    modelProfiles: Readonly<Record<string, string>>;
     modelContextWindowTokens?: number;
     visionModelId?: string;
     turnTimeoutMs: number;
     userName: string;
 }
-export interface AdvisorConfig {
-    modelId: string;
-    thinkingLevel: AdvisorThinkingLevel;
-}
 export type SqlDriver = "neon" | "postgres";
 export interface ChatConfig {
     bot: BotConfig;
@@ -67,4 +61,3 @@ export interface SlackReactionConfig {
 export declare function getSlackReactionConfig(): SlackReactionConfig;
 /** Apply Slack reaction emoji overrides from createApp() options, validating names. */
 export declare function setSlackReactionConfig(overrides: Partial<SlackReactionConfig>): void;
-export {};

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

@@ -2,18 +2,148 @@
  * Durable agent execution history port.
  *
  * Steps are appended one row at a time under the conversation lease; context
- * rebuilds (compaction/rollback) open a new epoch instead of rewriting history.
+ * rebuilds (compaction, handoff, rollback) open a new context epoch instead of
+ * rewriting history. Each new epoch binds the model profile that owns it and
+ * records the exact resolved model id for audit.
  * The step envelope is strictly validated — an unknown type or malformed shape
  * is corrupt state and fails loudly — while `pi_message` content stays
  * permissive because the Pi SDK owns the message shape.
  */
 import { z } from "zod";
-import { type PiMessage } from "@/chat/pi/messages";
-import { type PiMessageProvenance } from "@/chat/state/session-log";
-/** Reason a new context epoch was opened. */
-export type EpochReason = "compaction" | "rollback";
+declare const piMessageStepSchema: z.ZodObject<{
+    message: z.ZodPipe<z.ZodObject<{
+        role: z.ZodString;
+    }, 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;
+    }>>;
+    createdAtMs: z.ZodNumber;
+    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>>;
+}, z.core.$strict>;
+/** Validate one atomically persisted context epoch. */
+export declare const contextEpochStartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    reason: z.ZodLiteral<"initial">;
+    modelProfile: z.ZodLiteral<"standard">;
+    modelId: z.ZodString;
+    messages: z.ZodArray<z.ZodObject<{
+        message: z.ZodPipe<z.ZodObject<{
+            role: z.ZodString;
+        }, 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;
+        }>>;
+        createdAtMs: z.ZodNumber;
+        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>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    reason: z.ZodLiteral<"handoff">;
+    modelProfile: z.ZodString;
+    modelId: z.ZodString;
+    messages: z.ZodArray<z.ZodObject<{
+        message: z.ZodPipe<z.ZodObject<{
+            role: z.ZodString;
+        }, 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;
+        }>>;
+        createdAtMs: z.ZodNumber;
+        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>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    reason: z.ZodUnion<readonly [z.ZodLiteral<"compaction">, z.ZodLiteral<"rollback">]>;
+    modelProfile: z.ZodString;
+    modelId: z.ZodString;
+    messages: z.ZodArray<z.ZodObject<{
+        message: z.ZodPipe<z.ZodObject<{
+            role: z.ZodString;
+        }, 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;
+        }>>;
+        createdAtMs: z.ZodNumber;
+        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>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "reason">;
+/** One atomically persisted context epoch and its model binding. */
+export type ContextEpochStart = z.output<typeof contextEpochStartSchema>;
 /** Strict step envelope reused by the SQL row codec; unknown types fail loudly. */
-export declare const agentStepEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const agentStepEntrySchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
     type: z.ZodLiteral<"pi_message">;
     schemaVersion: z.ZodOptional<z.ZodNumber>;
     message: z.ZodPipe<z.ZodObject<{
@@ -42,9 +172,6 @@ export declare const agentStepEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<
             name: z.ZodString;
         }, z.core.$strict>], "platform">>;
     }, z.core.$strict>>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"context_epoch_started">;
-    reason: z.ZodUnion<readonly [z.ZodLiteral<"compaction">, z.ZodLiteral<"rollback">]>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"mcp_provider_connected">;
     provider: z.ZodString;
@@ -82,13 +209,33 @@ export declare const agentStepEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<
     parentToolCallId: z.ZodOptional<z.ZodString>;
     reasoningLevel: z.ZodOptional<z.ZodString>;
     childConversationId: z.ZodString;
-    historyMode: z.ZodLiteral<"shared">;
-}, z.core.$strip>, z.ZodObject<{
+    historyMode: z.ZodUnion<readonly [z.ZodLiteral<"isolated">, z.ZodLiteral<"shared">]>;
+}, z.core.$strict>, z.ZodObject<{
     type: z.ZodLiteral<"subagent_ended">;
     subagentInvocationId: z.ZodString;
     outcome: z.ZodUnion<readonly [z.ZodLiteral<"success">, z.ZodLiteral<"error">, z.ZodLiteral<"aborted">]>;
     errorCode: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>], "type">;
+}, z.core.$strip>]>, z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"context_epoch_started">;
+    reason: z.ZodLiteral<"initial">;
+    modelProfile: z.ZodLiteral<"standard">;
+    modelId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"context_epoch_started">;
+    reason: z.ZodLiteral<"handoff">;
+    modelProfile: z.ZodString;
+    modelId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"context_epoch_started">;
+    reason: z.ZodUnion<readonly [z.ZodLiteral<"compaction">, z.ZodLiteral<"rollback">]>;
+    modelProfile: z.ZodOptional<z.ZodUndefined>;
+    modelId: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"context_epoch_started">;
+    reason: z.ZodUnion<readonly [z.ZodLiteral<"compaction">, z.ZodLiteral<"rollback">]>;
+    modelProfile: z.ZodString;
+    modelId: z.ZodString;
+}, z.core.$strict>]>]>;
 /** One durable execution step's validated payload (sessionId lifted to epoch). */
 export type AgentStepEntry = z.infer<typeof agentStepEntrySchema>;
 /** A step read back from storage with its assigned order and epoch. */
@@ -98,31 +245,98 @@ export interface StoredAgentStep {
     createdAtMs: number;
     entry: AgentStepEntry;
 }
+/** Validate a current-epoch append without permitting epoch markers. */
+export declare const newAgentStepSchema: z.ZodObject<{
+    entry: z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"pi_message">;
+        schemaVersion: z.ZodOptional<z.ZodNumber>;
+        message: z.ZodPipe<z.ZodObject<{
+            role: z.ZodString;
+        }, 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;
+        }>>;
+        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>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"mcp_provider_connected">;
+        provider: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"authorization_requested">;
+        kind: z.ZodUnion<readonly [z.ZodLiteral<"plugin">, z.ZodLiteral<"mcp">]>;
+        provider: 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<{
+        type: z.ZodLiteral<"authorization_completed">;
+        kind: z.ZodUnion<readonly [z.ZodLiteral<"plugin">, z.ZodLiteral<"mcp">]>;
+        provider: z.ZodString;
+        actorId: z.ZodString;
+        authorizationId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_execution_started">;
+        toolCallId: z.ZodString;
+        toolName: z.ZodString;
+        args: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"visible_context_compacted">;
+        compactions: z.ZodArray<z.ZodObject<{
+            coveredMessageIds: z.ZodArray<z.ZodString>;
+            createdAtMs: z.ZodNumber;
+            id: z.ZodString;
+            summary: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"subagent_started">;
+        subagentInvocationId: z.ZodString;
+        subagentKind: z.ZodString;
+        modelId: z.ZodOptional<z.ZodString>;
+        parentToolCallId: z.ZodOptional<z.ZodString>;
+        reasoningLevel: z.ZodOptional<z.ZodString>;
+        childConversationId: z.ZodString;
+        historyMode: z.ZodUnion<readonly [z.ZodLiteral<"isolated">, z.ZodLiteral<"shared">]>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"subagent_ended">;
+        subagentInvocationId: z.ZodString;
+        outcome: z.ZodUnion<readonly [z.ZodLiteral<"success">, z.ZodLiteral<"error">, z.ZodLiteral<"aborted">]>;
+        errorCode: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>;
+    createdAtMs: z.ZodNumber;
+}, z.core.$strict>;
 /** A step to append; the store assigns `seq` and the current `context_epoch`. */
-export interface NewAgentStep {
-    entry: AgentStepEntry;
-    createdAtMs: number;
-}
+export type NewAgentStep = z.output<typeof newAgentStepSchema>;
 /** A replacement Pi message written into a freshly opened epoch. */
-export interface PiMessageStep {
-    message: PiMessage;
-    createdAtMs: number;
-    provenance?: PiMessageProvenance;
-}
+export type PiMessageStep = z.output<typeof piMessageStepSchema>;
 /** Persist and read the durable per-conversation agent execution history. */
 export interface AgentStepStore {
     /** Append steps in one transaction, assigning `seq = max+1` under the lease. */
     append(conversationId: string, steps: NewAgentStep[]): Promise<void>;
     /**
-     * Open the next epoch in one transaction: a `context_epoch_started` marker
-     * followed by the replacement messages as ordinary `pi_message` rows.
+     * Open initial epoch 0 or the next replacement epoch in one transaction.
      */
-    startEpoch(conversationId: string, opts: {
-        reason: EpochReason;
-        messages: PiMessageStep[];
-    }): Promise<void>;
+    startEpoch(conversationId: string, opts: ContextEpochStart): Promise<void>;
     /** Steps of the highest epoch in `seq` order (all types; caller filters). */
     loadCurrentEpoch(conversationId: string): Promise<StoredAgentStep[]>;
     /** All steps across all epochs in `seq` order, for audit and reporting. */
     loadHistory(conversationId: string): Promise<StoredAgentStep[]>;
 }
+export {};

package/dist/chat/conversations/legacy-advisor-session.d.ts

@@ -0,0 +1,7 @@
+import { type PiMessage } from "@/chat/pi/messages";
+/** Read historical advisor messages during the bounded Redis-to-SQL import. */
+export interface LegacyAdvisorSessionReader {
+    load: (conversationId: string) => Promise<PiMessage[]>;
+}
+/** Create the load-only reader for historical advisor session blobs. */
+export declare function createLegacyAdvisorSessionReader(): LegacyAdvisorSessionReader;

package/dist/chat/conversations/legacy-import.d.ts

@@ -1,6 +1,6 @@
 import { type ConversationCompaction, type ConversationMessage as ThreadConversationMessage } from "@/chat/state/conversation";
 import { type SessionLogStore } from "@/chat/state/session-log";
-import { type AdvisorSessionStore } from "@/chat/tools/advisor/session-store";
+import { type LegacyAdvisorSessionReader } from "@/chat/conversations/legacy-advisor-session";
 import type { JuniorSqlDatabase } from "@/db/db";
 import type { ConversationMessageStore } from "./messages";
 import type { Conversation } from "./store";
@@ -9,7 +9,7 @@ export interface LegacyImportDeps {
     executor: JuniorSqlDatabase;
     messageStore: ConversationMessageStore;
     sessionLogStore?: SessionLogStore;
-    advisorSessionStore?: AdvisorSessionStore;
+    advisorSessionStore?: LegacyAdvisorSessionReader;
     loadVisibleMessages?: (conversationId: string) => Promise<ThreadConversationMessage[]>;
     legacyCompactions?: ConversationCompaction[];
     /** Conversation metadata used for imported creation and activity clocks. */

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

@@ -1,8 +1,16 @@
 import type { PiMessage } from "@/chat/pi/messages";
 import { type AuthorizationKind, type PiMessageProvenance, type SessionProjection } from "@/chat/state/session-log";
 import type { StoredAgentStep } from "@/chat/conversations/history";
+import type { ModelProfile } from "@/chat/model-profile";
+/** Current conversation context with its authoritative model binding. */
+export interface ConversationProjection extends SessionProjection {
+    /** Model profile bound to this projection. */
+    modelProfile: ModelProfile;
+    /** Audit snapshot; runtime model selection remains profile-driven. */
+    modelId: string | undefined;
+}
 /** Aligned step projection: `provenance[i]` and `seqs[i]` describe `messages[i]`. */
-export interface StepProjection extends SessionProjection {
+export interface StepProjection extends ConversationProjection {
     /** The `seq` of the step each projected message came from. */
     seqs: number[];
 }
@@ -20,7 +28,11 @@ interface ScopedConversation {
 /** Load the current-epoch Pi projection for a conversation. */
 export declare function loadProjection(args: ScopedConversation): Promise<PiMessage[]>;
 /** Load the current-epoch Pi projection with aligned per-message provenance. */
-export declare function loadProjectionWithProvenance(args: ScopedConversation): Promise<SessionProjection>;
+export declare function loadConversationProjection(args: ScopedConversation): Promise<ConversationProjection>;
+/** Open a standard initial epoch before a conversation's first model request. */
+export declare function openConversationProjection(args: ScopedConversation & {
+    modelId: string;
+}): Promise<ConversationProjection>;
 /**
  * Load a turn's committed Pi projection from the durable step store.
  *
@@ -45,10 +57,14 @@ export declare function loadConnectedMcpProviders(args: ScopedConversation): Pro
  * projection normally, or open a `rollback` epoch when it diverged (a
  * provider-retry trim regenerated trailing assistant output). Returns the
  * resolved provenance, the per-message step seqs, and the `seq` boundary that
- * reproduces exactly the committed messages.
+ * reproduces exactly the committed messages. A first commit atomically opens
+ * the standard initial epoch; the run boundary opens it earlier when a model
+ * may act before any session checkpoint, such as recordless handoff.
  */
 export declare function commitMessages(args: {
     conversationId: string;
+    /** Exact model selected for this write; persisted for epoch audit only. */
+    modelId: string;
     messages: PiMessage[];
     /** Explicit per-message provenance aligned one-to-one with `messages`. */
     provenance?: PiMessageProvenance[];

package/dist/chat/conversations/sql/legacy-history-import.d.ts

@@ -28,7 +28,7 @@ export declare function convertLegacySessionLog(args: {
     entries: SessionLogEntry[];
     fallbackCreatedAtMs: number;
 }): ConvertedLegacyLog;
-/** Convert an advisor session blob into epoch-0 child pi_message rows. */
+/** Import advisor child rows while decoding the historical request envelope. */
 export declare function convertAdvisorMessages(messages: PiMessage[], fallbackCreatedAtMs: number): ImportedStep[];
 /** One conversation's converted history plus optional advisor child history. */
 export interface LegacyImportWrite {

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

@@ -1,15 +1,12 @@
 import type { Destination } from "@sentry/junior-plugin-api";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
 import type { StoredSlackActor } from "@/chat/actor";
-import type { JuniorSqlDatabase, JuniorSqlMigrationExecutor } from "@/db/db";
+import type { JuniorSqlDatabase } from "@/db/db";
 import type { Conversation, ConversationExecution, ConversationSource, ConversationStore } from "../store";
+import type { AgentTurnUsage } from "@/chat/usage";
 export declare class SqlStore implements ConversationStore {
     private readonly executor;
-    private readonly migrationExecutor;
-    private schemaReady;
-    constructor(executor: JuniorSqlDatabase, migrationExecutor: JuniorSqlMigrationExecutor);
-    /** Apply SQL schema migrations before runtime uses this store. */
-    migrate(): Promise<void>;
+    constructor(executor: JuniorSqlDatabase);
     get(args: {
         conversationId: string;
     }): Promise<Conversation | undefined>;
@@ -31,6 +28,10 @@ export declare class SqlStore implements ConversationStore {
         destination?: Destination;
         execution: ConversationExecution;
         lastActivityAtMs: number;
+        metrics: {
+            durationMs: number;
+            usage?: AgentTurnUsage;
+        } | null;
         actor?: StoredSlackActor;
         source?: ConversationSource;
         title?: string;
@@ -42,8 +43,13 @@ export declare class SqlStore implements ConversationStore {
         parentConversationId: string;
         nowMs?: number;
     }): Promise<void>;
-    /** Copy one conversation record into SQL during backfill. */
-    backfillConversation(sourceConversation: Conversation): Promise<void>;
+    /** Copy one conversation record and retained metrics into SQL during backfill. */
+    backfillConversation(sourceConversation: Conversation, metrics?: {
+        durationMs: number;
+        executionDurationMs: number;
+        executionUsage?: AgentTurnUsage;
+        usage?: AgentTurnUsage;
+    }): Promise<void>;
     listByActivity(args?: {
         limit?: number;
         offset?: number;
@@ -61,4 +67,4 @@ export declare class SqlStore implements ConversationStore {
     private upsertDestination;
 }
 /** Create a SQL-backed conversation store. */
-export declare function createSqlStore(executor: JuniorSqlMigrationExecutor): SqlStore;
+export declare function createSqlStore(executor: JuniorSqlDatabase): SqlStore;

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

@@ -1,6 +1,7 @@
 import type { Destination } from "@sentry/junior-plugin-api";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
 import type { StoredSlackActor } from "@/chat/actor";
+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 interface ConversationExecution {
@@ -57,10 +58,10 @@ export interface ConversationStore {
     /**
      * Establish a subagent child conversation row linked to its parent.
      *
-     * Advisor and future subagent histories live under their own child
-     * `conversation_id` with `parent_conversation_id` set; the child carries no
-     * destination and is excluded from top-level listings. Idempotent: it links a
-     * bare row a step append may have created first without clobbering it.
+     * Subagent histories live under their own child `conversation_id` with
+     * `parent_conversation_id` set; the child carries no destination and is
+     * excluded from top-level listings. Idempotent: it links a bare row a step
+     * append may have created first without clobbering it.
      */
     ensureChildConversation(args: {
         conversationId: string;
@@ -75,6 +76,10 @@ export interface ConversationStore {
         destination?: Destination;
         execution: ConversationExecution;
         lastActivityAtMs: number;
+        metrics: {
+            durationMs: number;
+            usage?: AgentTurnUsage;
+        } | null;
         actor?: StoredSlackActor;
         source?: ConversationSource;
         title?: string;

package/dist/chat/model-profile.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import type { BotConfig } from "@/chat/config";
+export declare const STANDARD_MODEL_PROFILE = "standard";
+export declare const DEFAULT_HANDOFF_MODEL_PROFILE = "handoff";
+/** Keep durable profile names stable and safe to expose in tool schemas. */
+export declare const modelProfileSchema: z.ZodString;
+/** A configured model role rather than a provider-specific model id. */
+export type ModelProfile = z.output<typeof modelProfileSchema>;
+/** Identify durable profile bindings that the current host cannot resolve. */
+export declare class ModelProfileNotConfiguredError extends Error {
+    constructor(profile: ModelProfile);
+}
+/** Resolve a stable model profile through the host-owned model catalog. */
+export declare function modelIdForProfile(config: BotConfig, profile: ModelProfile): string;

package/dist/chat/pi/transcript.d.ts

@@ -3,9 +3,9 @@
  *
  * Shape predicates and durable-history manipulation for raw Pi messages,
  * shared by the agent executor and the services that persist, trim, or
- * summarize transcripts. Volatile runtime turn context (the
- * `<runtime-turn-context>` bootstrap block) is stripped here so durable
- * history never retains per-session runtime instructions as user text.
+ * summarize transcripts. The utilities here strip stale
+ * `<runtime-turn-context>` bootstrap blocks before history is reused or
+ * replaced; an active completed projection may retain its current bootstrap.
  */
 import type { AssistantMessage, ToolResultMessage } from "@earendil-works/pi-ai";
 import type { PiMessage } from "@/chat/pi/messages";
@@ -27,6 +27,8 @@ export declare function getTerminalAssistantMessages(messages: readonly unknown[
 export declare function trimTrailingAssistantMessages(messages: PiMessage[]): PiMessage[];
 /** Return whether Pi history already carries session bootstrap context. */
 export declare function hasRuntimeTurnContext(messages: PiMessage[]): boolean;
+/** Keep only volatile bootstrap messages needed by an in-turn context replacement. */
+export declare function retainRuntimeTurnContext(messages: PiMessage[]): PiMessage[];
 /**
  * Reduce a runtime user-turn prompt to only the current turn's instruction.
  *

package/dist/chat/resource-events/store.d.ts

@@ -21,9 +21,9 @@ declare const subscriptionSchema: z.ZodObject<{
     resourceRef: z.ZodString;
     resourceType: z.ZodString;
     status: z.ZodEnum<{
-        cancelled: "cancelled";
-        completed: "completed";
         active: "active";
+        completed: "completed";
+        cancelled: "cancelled";
     }>;
     updatedAtMs: z.ZodNumber;
 }, z.core.$strict>;