@sentry/junior 0.106.0 → 0.107.1

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

@@ -0,0 +1,6 @@
+import type { ConversationEvent } from "./history";
+import type { ConversationMessage } from "@/chat/state/conversation";
+/** Reduce canonical message facts into destination-facing history. */
+export declare function projectConversationMessages(events: ConversationEvent[], options?: {
+    historyFromSeq?: number;
+}): ConversationMessage[];

package/dist/chat/conversations/message-summaries.d.ts

@@ -0,0 +1,9 @@
+import type { ConversationEvent } from "./history";
+import type { ConversationCompaction, ThreadConversationState } from "@/chat/state/conversation";
+/** Project the latest source-message summary snapshot from event history. */
+export declare function projectConversationMessageSummaries(events: ConversationEvent[]): ConversationCompaction[];
+/** Persist a changed source-message summary snapshot in event history. */
+export declare function persistConversationMessageSummaries(args: {
+    conversation: ThreadConversationState;
+    conversationId: string;
+}): Promise<void>;

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

@@ -1,9 +1,4 @@
-/**
- * Visible conversation message port.
- *
- * Messages are immutable source facts recorded idempotently by source identity;
- * the only mutable bookkeeping is the `replied_at` delivery mark.
- */
+import type { ConversationMessage, ThreadConversationState } from "@/chat/state/conversation";
 /** Author role of a visible conversation message. */
 export type ConversationMessageRole = "user" | "assistant" | "system";
 /** A source message to record; identity is `(conversationId, messageId)`. */
@@ -15,25 +10,16 @@ export interface NewConversationMessage {
     meta?: Record<string, unknown>;
     createdAtMs: number;
 }
-/** A visible message read back from storage. */
-export interface ConversationMessage {
-    conversationId: string;
-    messageId: string;
-    role: ConversationMessageRole;
-    text: string;
-    authorIdentityId?: string;
-    meta?: Record<string, unknown>;
+/** Serialize one in-memory message into its event-backed write shape. */
+export declare function toStoredConversationMessage(message: ConversationMessage): NewConversationMessage;
+/** Hydrate the current message working set from canonical conversation events. */
+export declare function hydrateConversationMessages(args: {
+    conversation: ThreadConversationState;
+    conversationId: string | undefined;
+}): Promise<void>;
+/** Append new messages and handled markers idempotently. */
+export declare function persistConversationMessages(args: {
+    conversation: ThreadConversationState;
+    conversationId: string | undefined;
     repliedAtMs?: number;
-    createdAtMs: number;
-}
-/** Persist and read the visible per-conversation message transcript. */
-export interface ConversationMessageStore {
-    /** Record source messages idempotently by `(conversation_id, message_id)`. */
-    record(conversationId: string, messages: NewConversationMessage[]): Promise<void>;
-    /** Set the mutable `replied_at` mark; content columns are never touched. */
-    markReplied(conversationId: string, messageId: string, repliedAtMs: number): Promise<void>;
-    /** List messages in `created_at` order. */
-    list(conversationId: string, opts?: {
-        limit?: number;
-    }): Promise<ConversationMessage[]>;
-}
+}): Promise<void>;

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

@@ -1,46 +1,24 @@
-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 ConversationProjection {
-    /** The `seq` of the step each projected message came from. */
-    seqs: number[];
-}
-/**
- * Materialize Pi messages with aligned provenance and source seqs from one
- * epoch's steps. Steps above `maxSeq` (when given) are excluded so a terminal
- * turn record reproduces exactly the boundary it committed.
- */
-export declare function projectSteps(steps: StoredAgentStep[], opts?: {
-    maxSeq?: number;
-}): StepProjection;
+import { type PiMessage } from "@/chat/pi/messages";
+import { type ConversationMessageProvenance } from "@/chat/conversations/provenance";
+import type { AuthorizationKind } from "@/chat/conversations/history";
+import type { JuniorSqlDatabase } from "@/db/db";
+import { type PiConversationEventProjection, type PiConversationProjection } from "@/chat/pi/conversation-events";
 interface ScopedConversation {
     conversationId: string;
 }
-/** Load the current-epoch Pi projection for a conversation. */
+/** Load the current Pi agent history 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 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 current Pi context with aligned provenance and source event sequences. */
+export declare function loadConversationProjection(args: ScopedConversation): Promise<PiConversationEventProjection>;
+/** Load the active Pi projection before a conversation's next request. */
+export declare function openConversationProjection(args: ScopedConversation): Promise<PiConversationProjection>;
 /**
- * Load a turn's committed Pi projection from the durable step store.
+ * Load a turn's committed Pi projection from the durable event store.
  *
- * The record stays pinned to the epoch containing its committed boundary, so a
- * later rollback or compaction cannot silently rewrite what a stale record
- * resumes from. Unfinished records (`includeTail`) also see that epoch's tail
- * so parked input appended after the last safe boundary is model-visible; for
- * a live run the committed epoch is the current epoch. Terminal records
+ * The record stays pinned to the history version containing its committed
+ * boundary, so later compaction cannot rewrite what a stale record resumes
+ * from. Unfinished records (`includeTail`) also see that version's tail so
+ * parked input appended after the last safe boundary is model-visible. Terminal records
  * reproduce exactly the boundary they committed by cutting at `committedSeq`.
  * Returns undefined when the committed boundary no longer exists (purged
  * history) so callers fail closed.
@@ -49,33 +27,33 @@ export declare function loadTurnProjection(args: {
     conversationId: string;
     committedSeq: number;
     includeTail: boolean;
-}): Promise<StepProjection | undefined>;
-/** Load MCP providers durably connected in this conversation's current epoch. */
+}): Promise<PiConversationEventProjection | undefined>;
+/** Load MCP providers connected in the current agent-history version. */
 export declare function loadConnectedMcpProviders(args: ScopedConversation): Promise<string[]>;
 /**
- * Commit the turn's Pi history: append when it advanced the committed
- * 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. 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.
+ * Append newly stable agent steps. A shorter or changed prefix indicates
+ * that a caller persisted volatile Pi state; only compaction and handoff may
+ * intentionally replace active model history.
  */
 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[];
+    provenance?: ConversationMessageProvenance[];
     /** Explicit provenance for the trailing newly committed messages. */
-    trailingMessageProvenance?: PiMessageProvenance[];
+    trailingMessageProvenance?: ConversationMessageProvenance[];
     /** Default applied to the last new user message when no explicit array. */
-    newMessageProvenance?: PiMessageProvenance;
+    newMessageProvenance?: ConversationMessageProvenance;
+    /** SQL authority for the atomic commit; defaults to the process executor. */
+    executor?: JuniorSqlDatabase;
 }): Promise<{
     committedSeq: number;
+    historyVersion: number;
+    /** Event sequence for every projected agent step. */
     messageSeqs: number[];
-    provenance: PiMessageProvenance[];
+    /** Normalized durable messages after volatile runtime context is removed. */
+    messages: PiMessage[];
+    provenance: ConversationMessageProvenance[];
 }>;
 /** Record a successful MCP provider connection without duplicating the fact. */
 export declare function recordMcpProviderConnected(args: {
@@ -102,7 +80,6 @@ export declare function recordAuthorizationCompleted(args: {
 /** Record a host-observed parent tool start without adding it to Pi replay. */
 export declare function recordToolExecutionStarted(args: {
     conversationId: string;
-    args?: unknown;
     createdAtMs?: number;
     toolCallId: string;
     toolName: string;

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

@@ -0,0 +1,42 @@
+/**
+ * Durable message attribution shared by storage and projections.
+ * Attribution never grants credential authority.
+ */
+import { type Actor } from "@sentry/junior-plugin-api";
+import { z } from "zod";
+declare const conversationMessageAuthoritySchema: z.ZodUnion<readonly [z.ZodLiteral<"instruction">, z.ZodLiteral<"context">]>;
+/** Canonical authority and actor metadata for one durable message event. */
+export declare const conversationMessageProvenanceSchema: 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 message is a durable instruction or ambient conversation context. */
+export type ConversationMessageAuthority = z.output<typeof conversationMessageAuthoritySchema>;
+/** Actor and authority metadata aligned with one durable message event. */
+export type ConversationMessageProvenance = z.output<typeof conversationMessageProvenanceSchema>;
+/** Build instruction provenance for an optional actor. */
+export declare function instructionProvenanceFor(actor: Actor | undefined): ConversationMessageProvenance;
+/** Unattributed ambient-context provenance for non-instruction messages. */
+export declare const contextProvenance: ConversationMessageProvenance;
+/**
+ * Return distinct instruction actors in first-seen order for attribution only.
+ * Never use this list as credential authority.
+ */
+export declare function instructionActors(provenance: ConversationMessageProvenance[]): Actor[];
+export {};

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

@@ -1,4 +1,4 @@
-/** One relevant visible-message match from a prior conversation. */
+/** One relevant chat-message match from a prior conversation. */
 export interface ConversationSearchResult {
     conversationId: string;
     excerpt: string;
@@ -13,7 +13,7 @@ export interface ConversationSearchScope {
     provider: "slack";
     providerTenantId: string;
 }
-/** Search retained public visible messages within an authorized workspace. */
+/** Search retained public messages within an authorized workspace. */
 export interface ConversationSearchStore {
     search(args: {
         currentConversationId: string;

package/dist/chat/conversations/sql/conversation-row.d.ts

@@ -1,7 +1,7 @@
 import type { JuniorSqlDatabase } from "@/db/db";
 /**
  * Establish the conversation metadata row on first contact for content writes
- * (agent steps, visible transcript) that can land before activity recording has
+ * (conversation events, visible transcript) that can land before activity has
  * created the row, and whose tables FK to it.
  *
  * First contact creates the row; every later content write advances the

package/dist/chat/conversations/sql/event-lock.d.ts

@@ -0,0 +1,3 @@
+import type { JuniorSqlDatabase } from "@/db/db";
+/** Serialize all event sequence allocation and visible projection writes. */
+export declare function withConversationEventLock<T>(executor: JuniorSqlDatabase, conversationId: string, callback: () => Promise<T>): Promise<T>;

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

@@ -1,4 +1,4 @@
 import type { JuniorSqlDatabase } from "@/db/db";
-import { type AgentStepStore } from "../history";
-/** Create a SQL-backed agent step store. */
-export declare function createSqlAgentStepStore(executor: JuniorSqlDatabase): AgentStepStore;
+import { type ConversationEventStore } from "../history";
+/** Create a SQL-backed canonical conversation event store. */
+export declare function createSqlConversationEventStore(executor: JuniorSqlDatabase): ConversationEventStore;

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

@@ -0,0 +1,27 @@
+import type { JuniorSqlDatabase } from "@/db/db";
+import { juniorConversationEvents } from "@/db/schema";
+import type { JuniorDestinationVisibility } from "@/db/schema/destinations";
+/** Root conversation identity and its normalized destination visibility. */
+export interface RootConversationVisibility {
+    rootConversationId: string;
+    visibility: JuniorDestinationVisibility | null;
+}
+type ConversationEventPrivacySnapshot = RootConversationVisibility & {
+    events: Array<typeof juniorConversationEvents.$inferSelect>;
+};
+/**
+ * Read selected event rows and their root privacy authority in one SQL snapshot.
+ */
+export declare function readConversationEventPrivacySnapshot(executor: JuniorSqlDatabase, args: {
+    conversationId: string;
+    eventTypes: readonly string[];
+}): Promise<ConversationEventPrivacySnapshot | undefined>;
+/**
+ * Resolve a conversation's privacy authority from its persisted root.
+ *
+ * Parent links are immutable after insertion. Missing, cyclic, or over-depth
+ * lineage fails closed, while the root destination is locked so callers that
+ * keep the transaction open receive a stable visibility decision.
+ */
+export declare function resolveRootVisibility(executor: JuniorSqlDatabase, conversationId: string): Promise<RootConversationVisibility>;
+export {};

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

@@ -28,7 +28,7 @@ export declare function selectExpiredRoots(executor: JuniorSqlDatabase, args: {
 }): Promise<ExpiredRoot[]>;
 /**
  * Purge one conversation tree in a single transaction: delete all message and
- * step rows for the given conversation and every descendant, stamp
+ * event rows for the given conversation and every descendant, stamp
  * `transcript_purged_at`, and — for non-public content — null the raw-payload
  * metadata (`title`, `channel_name`, legacy actor JSON) so purged private
  * conversations keep only safe metadata. The metadata rows themselves survive.
@@ -36,18 +36,10 @@ export declare function selectExpiredRoots(executor: JuniorSqlDatabase, args: {
 export declare function purgeConversationTree(executor: JuniorSqlDatabase, args: {
     rootConversationId: string;
     scrubMetadata?: boolean;
+    scrubMetadataFromRootVisibility?: boolean;
     nowMs: number;
     retention?: {
         privateWindowMs: number;
         publicWindowMs: number;
     };
 }): Promise<PurgeTreeResult>;
-/**
- * Walk `parent_conversation_id` to the root and return the root's destination
- * visibility. Retention resolves visibility at purge time rather than storing an
- * expiry, so a public↔private flip takes effect on the next pass.
- */
-export declare function resolveRootVisibility(executor: JuniorSqlDatabase, conversationId: string): Promise<{
-    rootConversationId: string;
-    visibility: JuniorDestinationVisibility | null;
-}>;

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

@@ -38,11 +38,6 @@ export declare class SqlStore implements ConversationStore {
         updatedAtMs: number;
         visibility?: ConversationPrivacy;
     }): Promise<void>;
-    ensureChildConversation(args: {
-        conversationId: string;
-        parentConversationId: string;
-        nowMs?: number;
-    }): Promise<void>;
     /** Copy one conversation record and retained metrics into SQL during backfill. */
     backfillConversation(sourceConversation: Conversation, metrics?: {
         durationMs: number;

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

@@ -11,6 +11,10 @@ export interface ConversationExecution {
     status: ConversationStatus;
     updatedAtMs?: number;
 }
+/** Immutable parent correlation for a child conversation. */
+export interface ConversationLineage {
+    parentConversationId: string;
+}
 export interface Conversation {
     archivedAtMs?: number;
     channelName?: string;
@@ -19,6 +23,7 @@ export interface Conversation {
     destination?: Destination;
     execution: ConversationExecution;
     lastActivityAtMs: number;
+    lineage?: ConversationLineage;
     actor?: StoredSlackActor;
     schemaVersion: 1;
     source?: ConversationSource;
@@ -26,7 +31,7 @@ export interface Conversation {
     updatedAtMs: number;
     /**
      * When retention purged this conversation's content. Set means messages and
-     * steps were deleted wholesale; reporting presents the transcript as expired
+     * events were deleted wholesale; reporting presents the transcript as expired
      * rather than privacy-redacted (`../../../../../policies/data-redaction.md`).
      */
     transcriptPurgedAtMs?: number;
@@ -57,19 +62,9 @@ export interface ConversationStore {
         visibility?: ConversationPrivacy;
     }): Promise<void>;
     /**
-     * Establish a subagent child conversation row linked to its parent.
-     *
-     * 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.
+     * Materialize execution and usage aggregates beside canonical metadata.
+     * These fields serve reporting and runtime control, never history hydration.
      */
-    ensureChildConversation(args: {
-        conversationId: string;
-        parentConversationId: string;
-        nowMs?: number;
-    }): Promise<void>;
-    /** Store task-execution metadata for long-term conversation history. */
     recordExecution(args: {
         channelName?: string;
         conversationId: string;

package/dist/chat/conversations/turn-lifecycle.d.ts

@@ -0,0 +1,41 @@
+import type { ConversationEventStore, ConversationTurnFailureCode } from "./history";
+/** Product-owned inputs for opening one correlated conversation turn. */
+export interface StartConversationTurnInput {
+    conversationId: string;
+    createdAtMs: number;
+    inputMessageIds: string[];
+    surface: "slack" | "api" | "scheduler" | "internal";
+    turnId: string;
+}
+/** Product-owned inputs for closing one correlated conversation turn. */
+export interface CompleteConversationTurnInput {
+    conversationId: string;
+    createdAtMs: number;
+    outcome: "success" | "no_reply";
+    turnId: string;
+}
+/** Privacy-safe inputs for failing one correlated conversation turn. */
+export interface FailConversationTurnInput {
+    conversationId: string;
+    createdAtMs: number;
+    eventId?: string;
+    failureCode: ConversationTurnFailureCode;
+    turnId: string;
+}
+/** Runtime port for correlated canonical turn lifecycle persistence. */
+export interface ConversationTurnLifecycle {
+    start(input: StartConversationTurnInput): Promise<void>;
+    complete(input: CompleteConversationTurnInput): Promise<void>;
+    fail(input: FailConversationTurnInput): Promise<void>;
+}
+/** Persist correlated turn lifecycle facts with retry-safe terminal exclusion. */
+export declare class ConversationTurnLifecycleService implements ConversationTurnLifecycle {
+    private readonly events;
+    constructor(events: ConversationEventStore);
+    /** Record the turn start once after every input message is durable. */
+    start(input: StartConversationTurnInput): Promise<void>;
+    /** Record successful or intentional-silence completion once. */
+    complete(input: CompleteConversationTurnInput): Promise<void>;
+    /** Record a classified failure once without accepting raw error details. */
+    fail(input: FailConversationTurnInput): Promise<void>;
+}

package/dist/chat/db.d.ts

@@ -1,21 +1,15 @@
 import type { ConversationStore } from "@/chat/conversations/store";
-import type { AgentStepStore } from "@/chat/conversations/history";
-import type { ConversationMessageStore } from "@/chat/conversations/messages";
+import type { ConversationEventStore } from "@/chat/conversations/history";
 import type { ConversationSearchStore } from "@/chat/conversations/search";
 import type { JuniorDatabase, JuniorSqlExecutor } from "@/db/db";
-/**
- * Return the process SQL executor. Exposed for the one-time legacy import
- * writer, which needs explicit-`seq`/epoch inserts the step-store port omits.
- */
+/** Return the process SQL executor for SQL-specific queries and transactions. */
 export declare function getSqlExecutor(): JuniorSqlExecutor;
 /** Return the process Drizzle database. */
 export declare function getDb(): JuniorDatabase;
 /** Return the SQL-backed conversation store. */
 export declare function getConversationStore(): ConversationStore;
-/** Return the SQL-backed durable agent step store. */
-export declare function getAgentStepStore(): AgentStepStore;
-/** Return the SQL-backed visible conversation message store. */
-export declare function getConversationMessageStore(): ConversationMessageStore;
+/** Return the canonical SQL-backed conversation event store. */
+export declare function getConversationEventStore(): ConversationEventStore;
 /** Return the SQL-backed public provider-tenant conversation search store. */
 export declare function getConversationSearchStore(): ConversationSearchStore;
 /** Close the process SQL database when it has been opened. */

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

@@ -1,14 +1,24 @@
 import { z } from "zod";
 import type { BotConfig } from "@/chat/config";
+import type { TurnReasoningLevel } from "@/chat/reasoning-level";
 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>;
+/** Runtime configuration for one named execution profile. */
+export interface ExecutionProfileConfig {
+    modelId: string;
+    reasoningLevel?: TurnReasoningLevel;
+}
 /** 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;
+/** Resolve the standard execution profile's model. */
+export declare function standardModelId(config: BotConfig): string;
+/** Resolve a stable model profile through the host-owned profile catalog. */
+export declare function profileConfig(config: BotConfig, profile: ModelProfile): ExecutionProfileConfig;

package/dist/chat/oauth-flow.d.ts

@@ -1,5 +1,4 @@
 import { type Destination, type Source } from "@sentry/junior-plugin-api";
-import type { ChannelConfigurationService } from "@/chat/configuration/types";
 type PrivateDeliveryResult = "in_context" | "fallback_dm" | false;
 export type OAuthStatePayload = {
     userId: string;
@@ -8,8 +7,6 @@ export type OAuthStatePayload = {
     destination?: Destination;
     source?: Source;
     threadTs?: string;
-    pendingMessage?: string;
-    configuration?: Record<string, unknown>;
     resumeConversationId?: string;
     resumeSessionId?: string;
     scope?: string;
@@ -20,8 +17,6 @@ type OAuthFlowInput = {
     destination?: Destination;
     source?: Source;
     threadTs?: string;
-    userMessage?: string;
-    channelConfiguration?: ChannelConfigurationService;
     activeSkillName?: string;
     resumeConversationId?: string;
     resumeSessionId?: string;

package/dist/chat/pi/conversation-events.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Pi adapter for Junior conversation events.
+ *
+ * Conversation storage owns the ordered event log. This module turns its
+ * stored messages into the active Pi context.
+ */
+import type { ModelProfile } from "@/chat/model-profile";
+import type { ConversationEvent } from "@/chat/conversations/history";
+import { type PiMessage } from "@/chat/pi/messages";
+import { type ConversationMessageProvenance } from "@/chat/conversations/provenance";
+/** Pi context projected from one Junior model-history version. */
+export interface PiConversationProjection {
+    messages: PiMessage[];
+    provenance: ConversationMessageProvenance[];
+    modelProfile: ModelProfile;
+    modelId: string | undefined;
+}
+/** Pi context with the source event sequence for every projected message. */
+export interface PiConversationEventProjection extends PiConversationProjection {
+    seqs: number[];
+}
+/**
+ * Project ordered Junior events into Pi context.
+ *
+ * Compaction and handoff start with replacement history. Later agent-step
+ * events append after it.
+ *
+ * Host-only events are filtered, completed authorization becomes a synthetic
+ * observation, and `maxSeq` reproduces an exact committed boundary.
+ */
+export declare function projectConversationEvents(events: ConversationEvent[], options?: {
+    maxSeq?: number;
+}): PiConversationEventProjection;

package/dist/chat/pi/sql-model-usage.d.ts

@@ -0,0 +1,10 @@
+import type { JuniorSqlDatabase } from "@/db/db";
+import { type AgentTurnUsage } from "@/chat/usage";
+/**
+ * Aggregate real assistant calls by provider/model in SQL. Replayed history is
+ * not another call; its tokens appear in the next call's input usage.
+ */
+export declare function readConversationModelUsageFromSql(executor: JuniorSqlDatabase, conversationId: string): Promise<Array<{
+    modelId: string;
+    usage: AgentTurnUsage;
+}>>;

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

@@ -1,4 +1,4 @@
-import type { PluginRoute, PluginOperationalReport, PluginRouteApp, SlackConversationLink, PluginRegistration } from "@sentry/junior-plugin-api";
+import type { PluginRoute, PluginOperationalReport, PluginRouteApp, ResourceEventPublisher, SlackConversationLink, PluginRegistration } from "@sentry/junior-plugin-api";
 import type { PluginPromptContributionContext } from "@/chat/plugins/prompt";
 import type { AnyToolDefinition } from "@/chat/tools/definition";
 import type { ToolRuntimeContext } from "@/chat/tools/types";
@@ -42,7 +42,9 @@ export declare function getPluginUserPromptContributions(args: {
 /** Collect turn-scoped tools exposed by plugins. */
 export declare function getPluginTools(context: ToolRuntimeContext): Record<string, AnyToolDefinition>;
 /** Collect route handlers exposed by plugins for app-level mounting. */
-export declare function getPluginRoutes(): PluginRouteRegistration[];
+export declare function getPluginRoutes(options: {
+    resourceEvents: ResourceEventPublisher;
+}): PluginRouteRegistration[];
 /** Collect authenticated product API route apps exposed by plugins. */
 export declare function getPluginApiRoutes(): PluginApiRouteRegistration[];
 /** Resolve the first plugin conversation URL for finalized Slack footers. */

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

@@ -1,17 +1,5 @@
 import type { StateAdapter } from "chat";
-import { z } from "zod";
 import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
-declare const ingestResourceEventInputSchema: z.ZodObject<{
-    eventKey: z.ZodString;
-    eventType: z.ZodString;
-    occurredAtMs: z.ZodNumber;
-    provider: z.ZodString;
-    resourceRef: z.ZodString;
-    terminal: z.ZodOptional<z.ZodBoolean>;
-    trustedSummary: z.ZodString;
-    untrustedText: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export type IngestResourceEventInput = z.output<typeof ingestResourceEventInputSchema>;
 /** Match a normalized provider event and enqueue notifications into conversations. */
 export declare function ingestResourceEvent(input: unknown, options: {
     nowMs?: number;
@@ -20,4 +8,3 @@ export declare function ingestResourceEvent(input: unknown, options: {
 }): Promise<{
     enqueued: number;
 }>;
-export {};

package/dist/chat/runtime/delivered-turn-state.d.ts

@@ -2,7 +2,7 @@ import type { AgentRunResult } from "@/chat/services/turn-result";
 import type { ThreadConversationState } from "@/chat/state/conversation";
 import type { ThreadArtifactsState } from "@/chat/state/artifacts";
 import { type ThreadStatePatch } from "@/chat/runtime/thread-state";
-/** Build the canonical thread-state patch after final Slack delivery succeeds. */
+/** Build state after destination delivery or intentional no-reply completion. */
 export declare function buildDeliveredTurnStatePatch(args: {
     artifactStatePatch?: Partial<ThreadArtifactsState>;
     artifacts: ThreadArtifactsState;

package/dist/chat/runtime/generated-artifacts.d.ts

@@ -1,5 +1,5 @@
 import type { FileUpload } from "chat";
-import type { GeneratedArtifactFileRef } from "@/chat/tools/types";
+import { type GeneratedArtifactFileRef } from "@/chat/tools/sandbox/file-uploads";
 import type { SandboxCommandResult } from "@/chat/sandbox/workspace";
 /** Sandbox operations needed to make generated artifacts visible to later tools. */
 export interface GeneratedArtifactSandbox {

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

@@ -16,6 +16,7 @@ import { type ConversationMemoryService } from "@/chat/services/conversation-mem
 import type { ContextCompactor } from "@/chat/services/context-compaction";
 import { lookupSlackUser } from "@/chat/slack/user";
 import type { AgentContinueRequest } from "@/chat/services/agent-continue";
+import type { ConversationTurnLifecycle } from "@/chat/conversations/turn-lifecycle";
 export interface ReplyExecutorServices {
     agentRunner: AgentRunner;
     contextCompactor: ContextCompactor;
@@ -25,6 +26,7 @@ export interface ReplyExecutorServices {
         sessionId: string;
     }) => Promise<AgentContinueRequest | undefined>;
     lookupSlackUser: typeof lookupSlackUser;
+    turnLifecycle: ConversationTurnLifecycle;
     scheduleAgentContinue: (request: AgentContinueRequest) => Promise<void>;
     scheduleSessionCompletedPluginTasks: (params: {
         conversationId: string;