@sentry/junior 0.96.0 → 0.97.1

package/dist/{chunk-RITD7E5L.js → chunk-35BNLDOJ.js}

@@ -1,8 +1,9 @@
 import {
   getChatConfig,
   getConnectedStateContext,
-  getStateAdapter
-} from "./chunk-YDVEH3SB.js";
+  getStateAdapter,
+  modelProfileSchema
+} from "./chunk-EEZCY5WX.js";
 import {
   parseDestination,
   sameDestination
@@ -174,12 +175,16 @@ var juniorConversations = pgTable4(
     runId: text4("run_id"),
     lastCheckpointAt: timestamptz("last_checkpoint_at"),
     lastEnqueuedAt: timestamptz("last_enqueued_at"),
-    // Subagent (advisor) runs are child conversations; top-level listings filter
-    // parent_conversation_id IS NULL.
+    // Subagent runs are child conversations; top-level listings filter
+    // parent_conversation_id IS NULL. Historical advisor children use this too.
     parentConversationId: text4("parent_conversation_id").references(
       () => juniorConversations.conversationId
     ),
-    transcriptPurgedAt: timestamptz("transcript_purged_at")
+    transcriptPurgedAt: timestamptz("transcript_purged_at"),
+    durationMs: integer("duration_ms").notNull().default(0),
+    usage: jsonb3("usage_json").$type(),
+    executionDurationMs: integer("execution_duration_ms").notNull().default(0),
+    executionUsage: jsonb3("execution_usage_json").$type()
   },
   (table) => [
     index3("junior_conversations_last_activity_idx").on(
@@ -255,14 +260,6 @@ var juniorConversationMessages = pgTable6(
   ]
 );
 
-// src/db/schema/migrations.ts
-import { pgTable as pgTable7, text as text7 } from "drizzle-orm/pg-core";
-var juniorSchemaMigrations = pgTable7("junior_schema_migrations", {
-  id: text7("id").primaryKey(),
-  checksum: text7("checksum").notNull(),
-  appliedAt: timestamptz("applied_at").notNull().defaultNow()
-});
-
 // src/db/schema.ts
 var juniorSqlSchema = {
   juniorAgentSteps,
@@ -270,7 +267,6 @@ var juniorSqlSchema = {
   juniorConversations,
   juniorDestinations,
   juniorIdentities,
-  juniorSchemaMigrations,
   juniorUsers
 };
 
@@ -379,396 +375,6 @@ async function upsertIdentity(executor, identity, nowMs = Date.now()) {
   };
 }
 
-// src/chat/conversations/sql/migrations.ts
-import { createHash } from "crypto";
-import { readFileSync } from "fs";
-import { fileURLToPath } from "url";
-import { z } from "zod";
-var MIGRATION_LOCK_NAME = "junior_conversation_schema";
-var migrationRecordSchema = z.object({
-  id: z.string().min(1),
-  checksum: z.string().min(1)
-}).strict();
-function checksumStatements(statements) {
-  const hash = createHash("sha256");
-  for (const statement of statements) {
-    hash.update(statement);
-    hash.update("\0");
-  }
-  return hash.digest("hex");
-}
-function defineMigration(id, statements) {
-  return {
-    id,
-    checksum: checksumStatements(statements),
-    statements
-  };
-}
-var createMigrationTable = `
-CREATE TABLE IF NOT EXISTS junior_schema_migrations (
-  id TEXT PRIMARY KEY,
-  checksum TEXT NOT NULL,
-  applied_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
-)
-`;
-var coreMetadataStatements = [
-  `
-CREATE TABLE IF NOT EXISTS junior_identities (
-  id TEXT PRIMARY KEY,
-  kind TEXT NOT NULL,
-  provider TEXT NOT NULL,
-  provider_tenant_id TEXT NOT NULL DEFAULT '',
-  provider_subject_id TEXT NOT NULL,
-  display_name TEXT,
-  handle TEXT,
-  email TEXT,
-  avatar_url TEXT,
-  metadata_json JSONB,
-  created_at TIMESTAMPTZ NOT NULL,
-  updated_at TIMESTAMPTZ NOT NULL
-)
-`,
-  `
-CREATE UNIQUE INDEX IF NOT EXISTS junior_identities_provider_subject_uidx
-  ON junior_identities (provider, provider_tenant_id, provider_subject_id)
-`,
-  `
-CREATE INDEX IF NOT EXISTS junior_identities_kind_provider_idx
-  ON junior_identities (kind, provider)
-`,
-  `
-CREATE TABLE IF NOT EXISTS junior_destinations (
-  id TEXT PRIMARY KEY,
-  provider TEXT NOT NULL,
-  provider_tenant_id TEXT NOT NULL DEFAULT '',
-  provider_destination_id TEXT NOT NULL,
-  kind TEXT NOT NULL,
-  parent_destination_id TEXT,
-  display_name TEXT,
-  visibility TEXT NOT NULL DEFAULT 'unknown',
-  metadata_json JSONB,
-  created_at TIMESTAMPTZ NOT NULL,
-  updated_at TIMESTAMPTZ NOT NULL
-)
-`,
-  `
-CREATE UNIQUE INDEX IF NOT EXISTS junior_destinations_provider_destination_uidx
-  ON junior_destinations (provider, provider_tenant_id, provider_destination_id)
-`,
-  `
-CREATE INDEX IF NOT EXISTS junior_destinations_provider_kind_idx
-  ON junior_destinations (provider, kind)
-`,
-  `
-CREATE TABLE IF NOT EXISTS junior_conversations (
-  conversation_id TEXT PRIMARY KEY,
-  schema_version INTEGER NOT NULL DEFAULT 1,
-  source TEXT,
-  origin_type TEXT,
-  origin_id TEXT,
-  origin_run_id TEXT,
-  destination_id TEXT REFERENCES junior_destinations (id),
-  destination_json JSONB,
-  actor_identity_id TEXT REFERENCES junior_identities (id),
-  requester_identity_id TEXT REFERENCES junior_identities (id),
-  creator_identity_id TEXT REFERENCES junior_identities (id),
-  credential_subject_identity_id TEXT REFERENCES junior_identities (id),
-  requester_json JSONB,
-  channel_name TEXT,
-  title TEXT,
-  created_at TIMESTAMPTZ NOT NULL,
-  last_activity_at TIMESTAMPTZ NOT NULL,
-  updated_at TIMESTAMPTZ NOT NULL,
-  execution_updated_at TIMESTAMPTZ,
-  execution_status TEXT NOT NULL,
-  run_id TEXT,
-  last_checkpoint_at TIMESTAMPTZ,
-  last_enqueued_at TIMESTAMPTZ
-)
-`,
-  `
-CREATE INDEX IF NOT EXISTS junior_conversations_last_activity_idx
-  ON junior_conversations (last_activity_at DESC, conversation_id)
-`,
-  `
-CREATE INDEX IF NOT EXISTS junior_conversations_active_idx
-  ON junior_conversations (coalesce(execution_updated_at, updated_at) ASC, conversation_id)
-  WHERE execution_status <> 'idle'
-`,
-  `
-CREATE INDEX IF NOT EXISTS junior_conversations_destination_activity_idx
-  ON junior_conversations (destination_id, last_activity_at DESC)
-`,
-  `
-CREATE INDEX IF NOT EXISTS junior_conversations_actor_activity_idx
-  ON junior_conversations (actor_identity_id, last_activity_at DESC)
-`,
-  `
-CREATE INDEX IF NOT EXISTS junior_conversations_requester_activity_idx
-  ON junior_conversations (requester_identity_id, last_activity_at DESC)
-`,
-  `
-CREATE INDEX IF NOT EXISTS junior_conversations_origin_idx
-  ON junior_conversations (origin_type, origin_id, last_activity_at DESC)
-`
-];
-var destinationVisibilityBackfillStatements = [
-  `
-UPDATE junior_destinations
-  SET visibility = 'private'
-  WHERE provider = 'slack'
-    AND visibility = 'public'
-`
-];
-var userIdentityStatements = [
-  `
-CREATE TABLE IF NOT EXISTS junior_users (
-  id TEXT PRIMARY KEY,
-  primary_email TEXT NOT NULL,
-  primary_email_normalized TEXT NOT NULL,
-  display_name TEXT,
-  created_at TIMESTAMPTZ NOT NULL,
-  updated_at TIMESTAMPTZ NOT NULL
-)
-`,
-  `
-CREATE UNIQUE INDEX IF NOT EXISTS junior_users_primary_email_normalized_uidx
-  ON junior_users (primary_email_normalized)
-`,
-  `
-ALTER TABLE junior_identities
-  ADD COLUMN IF NOT EXISTS user_id TEXT REFERENCES junior_users (id)
-`,
-  `
-ALTER TABLE junior_identities
-  ADD COLUMN IF NOT EXISTS email_normalized TEXT
-`,
-  `
-ALTER TABLE junior_identities
-  ADD COLUMN IF NOT EXISTS email_verified BOOLEAN NOT NULL DEFAULT false
-`,
-  `
-UPDATE junior_identities
-  SET email_normalized = lower(trim(email)),
-      email_verified = CASE
-        WHEN kind = 'user' AND provider = 'slack' THEN true
-        ELSE email_verified
-      END
-  WHERE email IS NOT NULL
-    AND trim(email) <> ''
-`,
-  `
-WITH first_identity AS (
-  SELECT DISTINCT ON (email_normalized)
-    id,
-    COALESCE(NULLIF(trim(email), ''), email_normalized) AS email,
-    email_normalized,
-    display_name,
-    created_at,
-    updated_at
-  FROM junior_identities
-  WHERE kind = 'user'
-    AND email_verified = true
-    AND email_normalized IS NOT NULL
-  ORDER BY email_normalized, created_at ASC, id ASC
-)
-INSERT INTO junior_users (
-  id,
-  primary_email,
-  primary_email_normalized,
-  display_name,
-  created_at,
-  updated_at
-)
-SELECT
-  'identity:' || id,
-  email,
-  email_normalized,
-  display_name,
-  created_at,
-  updated_at
-FROM first_identity
-ON CONFLICT (primary_email_normalized) DO NOTHING
-`,
-  `
-UPDATE junior_identities AS identity
-  SET user_id = junior_users.id
-  FROM junior_users
-  WHERE identity.kind = 'user'
-    AND identity.user_id IS NULL
-    AND identity.email_verified = true
-    AND identity.email_normalized = junior_users.primary_email_normalized
-`,
-  `
-CREATE INDEX IF NOT EXISTS junior_identities_user_idx
-  ON junior_identities (user_id)
-`,
-  `
-CREATE INDEX IF NOT EXISTS junior_identities_verified_email_idx
-  ON junior_identities (email_normalized)
-  WHERE email_verified = true
-    AND email_normalized IS NOT NULL
-`
-];
-var actorCutoverStatements = [
-  `
-UPDATE junior_conversations
-  SET actor_identity_id = requester_identity_id
-  WHERE requester_identity_id IS NOT NULL
-`,
-  `
-DO $$
-BEGIN
-  IF EXISTS (
-    SELECT 1
-    FROM information_schema.columns
-    WHERE table_name = 'junior_conversations'
-      AND column_name = 'requester_json'
-  ) AND NOT EXISTS (
-    SELECT 1
-    FROM information_schema.columns
-    WHERE table_name = 'junior_conversations'
-      AND column_name = 'actor_json'
-  ) THEN
-    ALTER TABLE junior_conversations
-      RENAME COLUMN requester_json TO actor_json;
-  END IF;
-END $$;
-`,
-  `
-ALTER TABLE junior_conversations
-  ADD COLUMN IF NOT EXISTS actor_json JSONB
-`,
-  `
-DO $$
-BEGIN
-  IF EXISTS (
-    SELECT 1
-    FROM information_schema.columns
-    WHERE table_name = 'junior_conversations'
-      AND column_name = 'requester_json'
-  ) THEN
-    UPDATE junior_conversations
-      SET actor_json = COALESCE(actor_json, requester_json);
-  END IF;
-END $$;
-`,
-  `
-DROP INDEX IF EXISTS junior_conversations_requester_activity_idx
-`,
-  `
-ALTER TABLE junior_conversations
-  DROP COLUMN IF EXISTS requester_identity_id
-`,
-  `
-ALTER TABLE junior_conversations
-  DROP COLUMN IF EXISTS requester_json
-`
-];
-var conversationTranscriptStatements = [
-  `
-CREATE TABLE IF NOT EXISTS junior_agent_steps (
-  conversation_id TEXT NOT NULL REFERENCES junior_conversations (conversation_id),
-  seq INTEGER NOT NULL,
-  context_epoch INTEGER NOT NULL,
-  type TEXT NOT NULL,
-  role TEXT,
-  payload JSONB NOT NULL,
-  created_at TIMESTAMPTZ NOT NULL,
-  PRIMARY KEY (conversation_id, seq)
-)
-`,
-  `
-CREATE INDEX IF NOT EXISTS junior_agent_steps_epoch_idx
-  ON junior_agent_steps (conversation_id, context_epoch, seq)
-`,
-  `
-CREATE TABLE IF NOT EXISTS junior_conversation_messages (
-  conversation_id TEXT NOT NULL REFERENCES junior_conversations (conversation_id),
-  message_id TEXT NOT NULL,
-  role TEXT NOT NULL,
-  author_identity_id TEXT REFERENCES junior_identities (id),
-  text TEXT NOT NULL,
-  meta JSONB,
-  replied_at TIMESTAMPTZ,
-  created_at TIMESTAMPTZ NOT NULL,
-  PRIMARY KEY (conversation_id, message_id)
-)
-`,
-  `
-CREATE INDEX IF NOT EXISTS junior_conversation_messages_activity_idx
-  ON junior_conversation_messages (conversation_id, created_at)
-`,
-  `
-ALTER TABLE junior_conversations
-  ADD COLUMN IF NOT EXISTS parent_conversation_id TEXT REFERENCES junior_conversations (conversation_id)
-`,
-  `
-ALTER TABLE junior_conversations
-  ADD COLUMN IF NOT EXISTS transcript_purged_at TIMESTAMPTZ
-`,
-  `
-CREATE INDEX IF NOT EXISTS junior_conversations_parent_idx
-  ON junior_conversations (parent_conversation_id)
-`
-];
-var migrations = [
-  defineMigration("0001_conversation_core", coreMetadataStatements),
-  defineMigration(
-    "0002_slack_destination_visibility_backfill",
-    destinationVisibilityBackfillStatements
-  ),
-  defineMigration("0003_user_identities", userIdentityStatements),
-  defineMigration("0004_actor_cutover", actorCutoverStatements),
-  defineMigration(
-    "0005_conversation_transcripts",
-    conversationTranscriptStatements
-  )
-];
-function parseStoredMigrationRecord(value) {
-  return migrationRecordSchema.parse(value);
-}
-async function listAppliedMigrations(executor) {
-  const rows = await executor.query(
-    "SELECT id, checksum FROM junior_schema_migrations ORDER BY id ASC"
-  );
-  const records = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const record = parseStoredMigrationRecord(row);
-    records.set(record.id, record);
-  }
-  return records;
-}
-async function applyMigration(executor, migration) {
-  await executor.transaction(async () => {
-    for (const statement of migration.statements) {
-      await executor.execute(statement);
-    }
-    await executor.execute(
-      "INSERT INTO junior_schema_migrations (id, checksum) VALUES ($1, $2)",
-      [migration.id, migration.checksum]
-    );
-  });
-}
-async function migrateSchema(executor, migrationList = migrations) {
-  await executor.withLock(MIGRATION_LOCK_NAME, async () => {
-    await executor.execute(createMigrationTable);
-    const applied = await listAppliedMigrations(executor);
-    for (const migration of migrationList) {
-      const existing = applied.get(migration.id);
-      if (existing) {
-        if (existing.checksum !== migration.checksum) {
-          throw new Error(
-            `Conversation migration ${migration.id} checksum changed`
-          );
-        }
-        continue;
-      }
-      await applyMigration(executor, migration);
-    }
-  });
-}
-
 // src/chat/conversations/sql/store.ts
 var CONVERSATION_MUTATION_LOCK_PREFIX = "junior_conversation";
 function now() {
@@ -1007,29 +613,42 @@ function mergeActor(current2, next) {
     ...current2.teamId ?? next.teamId ? { teamId: current2.teamId ?? next.teamId } : {}
   };
 }
+function tokenTotal(usage) {
+  if (!usage) return 0;
+  if (usage.totalTokens !== void 0) return usage.totalTokens;
+  return (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0) + (usage.cachedInputTokens ?? 0) + (usage.cacheCreationTokens ?? 0);
+}
+function updateConversationUsage(args) {
+  const usage = {
+    totalTokens: tokenTotal(args.current) - tokenTotal(args.previousExecution) + tokenTotal(args.nextExecution)
+  };
+  if (args.current?.reasoningTokens !== void 0 || args.previousExecution?.reasoningTokens !== void 0 || args.nextExecution.reasoningTokens !== void 0) {
+    usage.reasoningTokens = (args.current?.reasoningTokens ?? 0) - (args.previousExecution?.reasoningTokens ?? 0) + (args.nextExecution.reasoningTokens ?? 0);
+  }
+  const costFields = [
+    "input",
+    "output",
+    "cacheRead",
+    "cacheWrite",
+    "total"
+  ];
+  const cost = {};
+  for (const field of costFields) {
+    if (args.current?.cost?.[field] === void 0 && args.previousExecution?.cost?.[field] === void 0 && args.nextExecution.cost?.[field] === void 0) {
+      continue;
+    }
+    cost[field] = Math.round(
+      ((args.current?.cost?.[field] ?? 0) - (args.previousExecution?.cost?.[field] ?? 0) + (args.nextExecution.cost?.[field] ?? 0)) * 1e12
+    ) / 1e12;
+  }
+  if (Object.keys(cost).length > 0) usage.cost = cost;
+  return usage;
+}
 var SqlStore = class {
-  constructor(executor, migrationExecutor) {
+  constructor(executor) {
     this.executor = executor;
-    this.migrationExecutor = migrationExecutor;
   }
   executor;
-  migrationExecutor;
-  schemaReady;
-  /** Apply SQL schema migrations before runtime uses this store. */
-  async migrate() {
-    if (!this.schemaReady) {
-      this.schemaReady = migrateSchema(this.migrationExecutor);
-    }
-    const schemaReady = this.schemaReady;
-    try {
-      await schemaReady;
-    } catch (error) {
-      if (this.schemaReady === schemaReady) {
-        this.schemaReady = void 0;
-      }
-      throw error;
-    }
-  }
   async get(args) {
     const row = await this.readConversationRow(args.conversationId);
     if (!row) {
@@ -1079,6 +698,13 @@ var SqlStore = class {
   }
   async recordExecution(args) {
     await this.withConversationMutation(args.conversationId, async () => {
+      const existingRow = await this.readConversationRow(args.conversationId);
+      const existing = existingRow ? conversationFromRow(existingRow) : void 0;
+      const incomingExecutionAt = args.execution.updatedAtMs ?? args.updatedAtMs;
+      const existingExecutionAt = existing?.execution.updatedAtMs ?? existing?.updatedAtMs ?? 0;
+      const incomingIsFresh = incomingExecutionAt >= existingExecutionAt;
+      const sameRun = Boolean(existing?.execution.runId) && existing?.execution.runId === args.execution.runId;
+      const execution = incomingIsFresh ? args.execution : existing?.execution ?? args.execution;
       await this.upsertConversation({
         conversation: {
           schemaVersion: 1,
@@ -1092,9 +718,28 @@ var SqlStore = class {
           ...args.source ? { source: args.source } : {},
           ...args.title ? { title: args.title } : {},
           ...args.visibility ? { visibility: args.visibility } : {},
-          execution: args.execution
+          execution
         }
       });
+      if (incomingIsFresh && args.metrics) {
+        const row = existingRow?.conversation;
+        const usage = args.metrics.usage ? updateConversationUsage({
+          current: row?.usage ?? void 0,
+          previousExecution: sameRun ? row?.executionUsage ?? void 0 : void 0,
+          nextExecution: args.metrics.usage
+        }) : row?.usage ?? void 0;
+        await this.executor.db().update(juniorConversations).set({
+          durationMs: (row?.durationMs ?? 0) - (sameRun ? row?.executionDurationMs ?? 0 : 0) + args.metrics.durationMs,
+          usage: usage ?? null,
+          executionDurationMs: args.metrics.durationMs,
+          executionUsage: args.metrics.usage ?? (sameRun ? row?.executionUsage ?? null : null)
+        }).where(eq2(juniorConversations.conversationId, args.conversationId));
+      } else if (incomingIsFresh && !sameRun) {
+        await this.executor.db().update(juniorConversations).set({
+          executionDurationMs: 0,
+          executionUsage: null
+        }).where(eq2(juniorConversations.conversationId, args.conversationId));
+      }
     });
   }
   async ensureChildConversation(args) {
@@ -1122,8 +767,8 @@ var SqlStore = class {
       }
     });
   }
-  /** Copy one conversation record into SQL during backfill. */
-  async backfillConversation(sourceConversation) {
+  /** Copy one conversation record and retained metrics into SQL during backfill. */
+  async backfillConversation(sourceConversation, metrics) {
     const { visibility: _visibility, ...conversation } = sourceConversation;
     await this.withConversationMutation(
       conversation.conversationId,
@@ -1156,6 +801,25 @@ var SqlStore = class {
           execution: refreshExecutionFromSource ? conversation.execution : existing.execution
         } : conversation;
         await this.upsertConversation({ conversation: mergedConversation });
+        if (metrics) {
+          await this.executor.db().update(juniorConversations).set({
+            durationMs: metrics.durationMs,
+            usage: metrics.usage ?? null,
+            ...refreshExecutionFromSource ? {
+              executionDurationMs: metrics.executionDurationMs,
+              executionUsage: metrics.executionUsage ?? null
+            } : {}
+          }).where(
+            and2(
+              eq2(
+                juniorConversations.conversationId,
+                conversation.conversationId
+              ),
+              eq2(juniorConversations.durationMs, 0),
+              isNull(juniorConversations.usage)
+            )
+          );
+        }
       }
     );
   }
@@ -1329,39 +993,39 @@ var SqlStore = class {
   }
 };
 function createSqlStore(executor) {
-  return new SqlStore(executor, executor);
+  return new SqlStore(executor);
 }
 
 // src/chat/conversations/sql/history.ts
 import { and as and3, asc as asc2, eq as eq3, sql as sql6 } from "drizzle-orm";
 
 // src/chat/conversations/history.ts
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
 
 // src/chat/pi/messages.ts
-import { z as z2 } from "zod";
-var piMessageSchema = z2.object({
-  role: z2.string()
+import { z } from "zod";
+var piMessageSchema = z.object({
+  role: z.string()
 }).passthrough().transform((value) => value);
-var piContentMessageSchema = z2.object({
-  content: z2.array(z2.unknown()),
-  role: z2.string().min(1)
+var piContentMessageSchema = z.object({
+  content: z.array(z.unknown()),
+  role: z.string().min(1)
 }).passthrough().transform((value) => value);
 
 // src/chat/state/session-log.ts
 import { isDeepStrictEqual } from "util";
-import { z as z3 } from "zod";
+import { z as z2 } from "zod";
 import { actorSchema } from "@sentry/junior-plugin-api";
 var AGENT_SESSION_LOG_PREFIX = "junior:agent-session-log";
 var AGENT_SESSION_LOG_SCHEMA_VERSION = 2;
 var INITIAL_SESSION_ID = "session_0";
 var STATE_STORE_LOCK_TTL_MS = 5e3;
-var schemaVersionSchema = z3.union([z3.literal(1), z3.literal(2)]);
-var piMessageAuthoritySchema = z3.union([
-  z3.literal("instruction"),
-  z3.literal("context")
+var schemaVersionSchema = z2.union([z2.literal(1), z2.literal(2)]);
+var piMessageAuthoritySchema = z2.union([
+  z2.literal("instruction"),
+  z2.literal("context")
 ]);
-var piMessageProvenanceSchema = z3.object({
+var piMessageProvenanceSchema = z2.object({
   authority: piMessageAuthoritySchema,
   actor: actorSchema.optional()
 }).strict();
@@ -1387,109 +1051,109 @@ function legacyActorProvenance(actor) {
   }
   return unattributedContextProvenance;
 }
-var piMessageEntrySchema = z3.object({
+var piMessageEntrySchema = z2.object({
   schemaVersion: schemaVersionSchema,
-  type: z3.literal("pi_message"),
-  sessionId: z3.string().min(1).default(INITIAL_SESSION_ID),
+  type: z2.literal("pi_message"),
+  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
   message: piMessageSchema,
   provenance: piMessageProvenanceSchema.optional(),
   // Legacy v1 latest-wins actor, decoded into provenance on read.
   actor: storedSlackActorSchema.optional()
 });
-var projectionResetEntrySchema = z3.object({
+var projectionResetEntrySchema = z2.object({
   schemaVersion: schemaVersionSchema,
-  type: z3.literal("projection_reset"),
-  sessionId: z3.string().min(1).default(INITIAL_SESSION_ID),
-  messages: z3.array(piMessageSchema),
-  provenance: z3.array(piMessageProvenanceSchema).optional(),
+  type: z2.literal("projection_reset"),
+  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
+  messages: z2.array(piMessageSchema),
+  provenance: z2.array(piMessageProvenanceSchema).optional(),
   // Legacy v1 latest-wins actor; v1 resets carry no per-message provenance.
   actor: storedSlackActorSchema.optional()
 });
-var actorRecordedEntrySchema = z3.object({
+var actorRecordedEntrySchema = z2.object({
   schemaVersion: schemaVersionSchema,
-  type: z3.literal("actor_recorded"),
-  sessionId: z3.string().min(1).default(INITIAL_SESSION_ID),
+  type: z2.literal("actor_recorded"),
+  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
   actor: storedSlackActorSchema
 });
-var mcpProviderConnectedEntrySchema = z3.object({
+var mcpProviderConnectedEntrySchema = z2.object({
   schemaVersion: schemaVersionSchema,
-  type: z3.literal("mcp_provider_connected"),
-  sessionId: z3.string().min(1).default(INITIAL_SESSION_ID),
-  provider: z3.string().min(1)
+  type: z2.literal("mcp_provider_connected"),
+  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
+  provider: z2.string().min(1)
 });
-var authorizationKindSchema = z3.union([
-  z3.literal("plugin"),
-  z3.literal("mcp")
+var authorizationKindSchema = z2.union([
+  z2.literal("plugin"),
+  z2.literal("mcp")
 ]);
-var authorizationRequestedEntrySchema = z3.object({
+var authorizationRequestedEntrySchema = z2.object({
   schemaVersion: schemaVersionSchema,
-  type: z3.literal("authorization_requested"),
-  sessionId: z3.string().min(1).default(INITIAL_SESSION_ID),
-  createdAtMs: z3.number().int().nonnegative(),
+  type: z2.literal("authorization_requested"),
+  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
+  createdAtMs: z2.number().int().nonnegative(),
   kind: authorizationKindSchema,
-  provider: z3.string().min(1),
-  actorId: z3.string().min(1),
-  authorizationId: z3.string().min(1),
-  delivery: z3.union([
-    z3.literal("private_link_sent"),
-    z3.literal("private_link_reused")
+  provider: z2.string().min(1),
+  actorId: z2.string().min(1),
+  authorizationId: z2.string().min(1),
+  delivery: z2.union([
+    z2.literal("private_link_sent"),
+    z2.literal("private_link_reused")
   ])
 });
-var authorizationCompletedEntrySchema = z3.object({
+var authorizationCompletedEntrySchema = z2.object({
   schemaVersion: schemaVersionSchema,
-  type: z3.literal("authorization_completed"),
-  sessionId: z3.string().min(1).default(INITIAL_SESSION_ID),
-  createdAtMs: z3.number().int().nonnegative(),
+  type: z2.literal("authorization_completed"),
+  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
+  createdAtMs: z2.number().int().nonnegative(),
   kind: authorizationKindSchema,
-  provider: z3.string().min(1),
-  actorId: z3.string().min(1),
-  authorizationId: z3.string().min(1)
+  provider: z2.string().min(1),
+  actorId: z2.string().min(1),
+  authorizationId: z2.string().min(1)
 });
-var transcriptRefSchema = z3.object({
-  type: z3.literal("advisor_session"),
-  parentConversationId: z3.string().min(1),
-  key: z3.string().min(1)
+var transcriptRefSchema = z2.object({
+  type: z2.literal("advisor_session"),
+  parentConversationId: z2.string().min(1),
+  key: z2.string().min(1)
 });
-var toolExecutionStartedEntrySchema = z3.object({
+var toolExecutionStartedEntrySchema = z2.object({
   schemaVersion: schemaVersionSchema,
-  type: z3.literal("tool_execution_started"),
-  sessionId: z3.string().min(1).default(INITIAL_SESSION_ID),
-  createdAtMs: z3.number().int().nonnegative(),
-  toolCallId: z3.string().min(1),
-  toolName: z3.string().min(1),
-  args: z3.unknown().optional()
+  type: z2.literal("tool_execution_started"),
+  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
+  createdAtMs: z2.number().int().nonnegative(),
+  toolCallId: z2.string().min(1),
+  toolName: z2.string().min(1),
+  args: z2.unknown().optional()
 });
-var subagentStartedEntrySchema = z3.object({
+var subagentStartedEntrySchema = z2.object({
   schemaVersion: schemaVersionSchema,
-  type: z3.literal("subagent_started"),
-  sessionId: z3.string().min(1).default(INITIAL_SESSION_ID),
-  subagentInvocationId: z3.string().min(1),
-  subagentKind: z3.string().min(1),
-  parentToolCallId: z3.string().min(1).optional(),
-  parentConversationId: z3.string().min(1),
-  parentSessionId: z3.string().min(1).optional(),
+  type: z2.literal("subagent_started"),
+  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
+  subagentInvocationId: z2.string().min(1),
+  subagentKind: z2.string().min(1),
+  parentToolCallId: z2.string().min(1).optional(),
+  parentConversationId: z2.string().min(1),
+  parentSessionId: z2.string().min(1).optional(),
   transcriptRef: transcriptRefSchema,
-  historyMode: z3.literal("shared"),
-  modelId: z3.string().min(1).optional(),
-  reasoningLevel: z3.string().min(1).optional(),
-  createdAtMs: z3.number().int().nonnegative()
+  historyMode: z2.literal("shared"),
+  modelId: z2.string().min(1).optional(),
+  reasoningLevel: z2.string().min(1).optional(),
+  createdAtMs: z2.number().int().nonnegative()
 });
-var subagentEndedEntrySchema = z3.object({
+var subagentEndedEntrySchema = z2.object({
   schemaVersion: schemaVersionSchema,
-  type: z3.literal("subagent_ended"),
-  sessionId: z3.string().min(1).default(INITIAL_SESSION_ID),
-  subagentInvocationId: z3.string().min(1),
-  outcome: z3.union([
-    z3.literal("success"),
-    z3.literal("error"),
-    z3.literal("aborted")
+  type: z2.literal("subagent_ended"),
+  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
+  subagentInvocationId: z2.string().min(1),
+  outcome: z2.union([
+    z2.literal("success"),
+    z2.literal("error"),
+    z2.literal("aborted")
   ]),
-  errorCode: z3.string().min(1).optional(),
-  transcriptEndMessageIndex: z3.number().int().nonnegative().optional(),
-  transcriptStartMessageIndex: z3.number().int().nonnegative().optional(),
-  createdAtMs: z3.number().int().nonnegative()
+  errorCode: z2.string().min(1).optional(),
+  transcriptEndMessageIndex: z2.number().int().nonnegative().optional(),
+  transcriptStartMessageIndex: z2.number().int().nonnegative().optional(),
+  createdAtMs: z2.number().int().nonnegative()
 });
-var sessionLogEntrySchema = z3.discriminatedUnion("type", [
+var sessionLogEntrySchema = z2.discriminatedUnion("type", [
   piMessageEntrySchema,
   projectionResetEntrySchema,
   actorRecordedEntrySchema,
@@ -1651,82 +1315,134 @@ function instructionProvenanceFor(actor) {
 var contextProvenance = unattributedContextProvenance;
 
 // src/chat/conversations/history.ts
-var piMessageStepEntrySchema = z4.object({
-  type: z4.literal("pi_message"),
-  schemaVersion: z4.number().int().optional(),
+var handoffModelProfileSchema = modelProfileSchema.refine(
+  (profile) => profile !== "standard",
+  "handoff profile must not be standard"
+);
+var piMessageStepEntrySchema = z3.object({
+  type: z3.literal("pi_message"),
+  schemaVersion: z3.number().int().optional(),
   message: piMessageSchema,
   provenance: piMessageProvenanceSchema.optional()
 });
-var contextEpochStartedEntrySchema = z4.object({
-  type: z4.literal("context_epoch_started"),
-  reason: z4.union([z4.literal("compaction"), z4.literal("rollback")])
-});
-var mcpProviderConnectedEntrySchema2 = z4.object({
-  type: z4.literal("mcp_provider_connected"),
-  provider: z4.string().min(1)
+var contextEpochStartedEntrySchema = z3.union([
+  z3.object({
+    type: z3.literal("context_epoch_started"),
+    reason: z3.literal("initial"),
+    modelProfile: z3.literal("standard"),
+    modelId: z3.string().min(1)
+  }).strict(),
+  z3.object({
+    type: z3.literal("context_epoch_started"),
+    reason: z3.literal("handoff"),
+    modelProfile: handoffModelProfileSchema,
+    modelId: z3.string().min(1)
+  }).strict(),
+  z3.object({
+    type: z3.literal("context_epoch_started"),
+    reason: z3.union([z3.literal("compaction"), z3.literal("rollback")]),
+    // TODO(v0.97.0): Remove support for deployed compaction/rollback markers
+    // without model bindings after those rows pass the retention horizon.
+    modelProfile: z3.undefined().optional(),
+    modelId: z3.undefined().optional()
+  }).strict(),
+  z3.object({
+    type: z3.literal("context_epoch_started"),
+    reason: z3.union([z3.literal("compaction"), z3.literal("rollback")]),
+    modelProfile: modelProfileSchema,
+    modelId: z3.string().min(1)
+  }).strict()
+]);
+var piMessageStepSchema = z3.object({
+  message: piMessageSchema,
+  createdAtMs: z3.number().finite(),
+  provenance: piMessageProvenanceSchema.optional()
+}).strict();
+var contextEpochStartSchema = z3.discriminatedUnion("reason", [
+  z3.object({
+    reason: z3.literal("initial"),
+    modelProfile: z3.literal("standard"),
+    modelId: z3.string().min(1),
+    messages: z3.array(piMessageStepSchema)
+  }).strict(),
+  z3.object({
+    reason: z3.literal("handoff"),
+    modelProfile: handoffModelProfileSchema,
+    modelId: z3.string().min(1),
+    messages: z3.array(piMessageStepSchema)
+  }).strict(),
+  z3.object({
+    reason: z3.union([z3.literal("compaction"), z3.literal("rollback")]),
+    modelProfile: modelProfileSchema,
+    modelId: z3.string().min(1),
+    messages: z3.array(piMessageStepSchema)
+  }).strict()
+]);
+var mcpProviderConnectedEntrySchema2 = z3.object({
+  type: z3.literal("mcp_provider_connected"),
+  provider: z3.string().min(1)
 });
-var authorizationKindSchema2 = z4.union([
-  z4.literal("plugin"),
-  z4.literal("mcp")
+var authorizationKindSchema2 = z3.union([
+  z3.literal("plugin"),
+  z3.literal("mcp")
 ]);
-var authorizationRequestedEntrySchema2 = z4.object({
-  type: z4.literal("authorization_requested"),
+var authorizationRequestedEntrySchema2 = z3.object({
+  type: z3.literal("authorization_requested"),
   kind: authorizationKindSchema2,
-  provider: z4.string().min(1),
-  actorId: z4.string().min(1),
-  authorizationId: z4.string().min(1),
-  delivery: z4.union([
-    z4.literal("private_link_sent"),
-    z4.literal("private_link_reused")
+  provider: z3.string().min(1),
+  actorId: z3.string().min(1),
+  authorizationId: z3.string().min(1),
+  delivery: z3.union([
+    z3.literal("private_link_sent"),
+    z3.literal("private_link_reused")
   ])
 });
-var authorizationCompletedEntrySchema2 = z4.object({
-  type: z4.literal("authorization_completed"),
+var authorizationCompletedEntrySchema2 = z3.object({
+  type: z3.literal("authorization_completed"),
   kind: authorizationKindSchema2,
-  provider: z4.string().min(1),
-  actorId: z4.string().min(1),
-  authorizationId: z4.string().min(1)
+  provider: z3.string().min(1),
+  actorId: z3.string().min(1),
+  authorizationId: z3.string().min(1)
 });
-var toolExecutionStartedEntrySchema2 = z4.object({
-  type: z4.literal("tool_execution_started"),
-  toolCallId: z4.string().min(1),
-  toolName: z4.string().min(1),
-  args: z4.unknown().optional()
+var toolExecutionStartedEntrySchema2 = z3.object({
+  type: z3.literal("tool_execution_started"),
+  toolCallId: z3.string().min(1),
+  toolName: z3.string().min(1),
+  args: z3.unknown().optional()
 });
-var visibleContextCompactedEntrySchema = z4.object({
-  type: z4.literal("visible_context_compacted"),
-  compactions: z4.array(
-    z4.object({
-      coveredMessageIds: z4.array(z4.string()),
-      createdAtMs: z4.number(),
-      id: z4.string().min(1),
-      summary: z4.string()
+var visibleContextCompactedEntrySchema = z3.object({
+  type: z3.literal("visible_context_compacted"),
+  compactions: z3.array(
+    z3.object({
+      coveredMessageIds: z3.array(z3.string()),
+      createdAtMs: z3.number(),
+      id: z3.string().min(1),
+      summary: z3.string()
     })
   )
 });
-var subagentStartedEntrySchema2 = z4.object({
-  type: z4.literal("subagent_started"),
-  subagentInvocationId: z4.string().min(1),
-  subagentKind: z4.string().min(1),
-  modelId: z4.string().min(1).optional(),
-  parentToolCallId: z4.string().min(1).optional(),
-  reasoningLevel: z4.string().min(1).optional(),
-  childConversationId: z4.string().min(1),
-  historyMode: z4.literal("shared")
-});
-var subagentEndedEntrySchema2 = z4.object({
-  type: z4.literal("subagent_ended"),
-  subagentInvocationId: z4.string().min(1),
-  outcome: z4.union([
-    z4.literal("success"),
-    z4.literal("error"),
-    z4.literal("aborted")
+var subagentStartedEntrySchema2 = z3.object({
+  type: z3.literal("subagent_started"),
+  subagentInvocationId: z3.string().min(1),
+  subagentKind: z3.string().min(1),
+  modelId: z3.string().min(1).optional(),
+  parentToolCallId: z3.string().min(1).optional(),
+  reasoningLevel: z3.string().min(1).optional(),
+  childConversationId: z3.string().min(1),
+  historyMode: z3.union([z3.literal("isolated"), z3.literal("shared")])
+}).strict();
+var subagentEndedEntrySchema2 = z3.object({
+  type: z3.literal("subagent_ended"),
+  subagentInvocationId: z3.string().min(1),
+  outcome: z3.union([
+    z3.literal("success"),
+    z3.literal("error"),
+    z3.literal("aborted")
   ]),
-  errorCode: z4.string().min(1).optional()
+  errorCode: z3.string().min(1).optional()
 });
-var agentStepEntrySchema = z4.discriminatedUnion("type", [
+var appendableAgentStepEntrySchema = z3.union([
   piMessageStepEntrySchema,
-  contextEpochStartedEntrySchema,
   mcpProviderConnectedEntrySchema2,
   authorizationRequestedEntrySchema2,
   authorizationCompletedEntrySchema2,
@@ -1735,6 +1451,14 @@ var agentStepEntrySchema = z4.discriminatedUnion("type", [
   subagentStartedEntrySchema2,
   subagentEndedEntrySchema2
 ]);
+var agentStepEntrySchema = z3.union([
+  appendableAgentStepEntrySchema,
+  contextEpochStartedEntrySchema
+]);
+var newAgentStepSchema = z3.object({
+  entry: appendableAgentStepEntrySchema,
+  createdAtMs: z3.number().finite()
+}).strict();
 
 // src/chat/conversations/sql/conversation-row.ts
 import { sql as sql5 } from "drizzle-orm";
@@ -1801,11 +1525,12 @@ var SqlAgentStepStore = class {
   }
   executor;
   async append(conversationId, steps) {
-    if (steps.length === 0) {
+    const parsed = steps.map((step) => newAgentStepSchema.parse(step));
+    if (parsed.length === 0) {
       return;
     }
     const newestCreatedAtMs = Math.max(
-      ...steps.map((step) => step.createdAtMs)
+      ...parsed.map((step) => step.createdAtMs)
     );
     await this.executor.transaction(async () => {
       await ensureConversationRow(
@@ -1816,23 +1541,25 @@ var SqlAgentStepStore = class {
       const cursor = await this.readCursor(conversationId);
       const contextEpoch = cursor.maxEpoch ?? 0;
       let seq = cursor.nextSeq;
-      const rows = steps.map(
+      const rows = parsed.map(
         (step) => insertFromStep(conversationId, seq++, contextEpoch, step)
       );
       await this.executor.db().insert(juniorAgentSteps).values(rows);
     });
   }
   async startEpoch(conversationId, opts) {
+    const parsed = contextEpochStartSchema.parse(opts);
     await this.executor.transaction(async () => {
       await ensureConversationRow(this.executor, conversationId, Date.now());
       const cursor = await this.readCursor(conversationId);
-      const contextEpoch = (cursor.maxEpoch ?? -1) + 1;
+      const contextEpoch = parsed.reason === "initial" ? cursor.maxEpoch ?? 0 : (cursor.maxEpoch ?? -1) + 1;
       let seq = cursor.nextSeq;
+      const { messages, ...binding } = parsed;
       const marker = {
-        entry: { type: "context_epoch_started", reason: opts.reason },
+        entry: { type: "context_epoch_started", ...binding },
         createdAtMs: Date.now()
       };
-      const rows = [marker, ...opts.messages.map(piMessageStep)].map(
+      const rows = [marker, ...messages.map(piMessageStep)].map(
         (step) => insertFromStep(conversationId, seq++, contextEpoch, step)
       );
       await this.executor.db().insert(juniorAgentSteps).values(rows);
@@ -1957,6 +1684,7 @@ import {
   Pool
 } from "@neondatabase/serverless";
 import { drizzle } from "drizzle-orm/neon-serverless";
+import { migrate } from "drizzle-orm/neon-serverless/migrator";
 var NeonExecutor = class {
   constructor(pool) {
     this.pool = pool;
@@ -1978,6 +1706,12 @@ var NeonExecutor = class {
     ]);
     return result.rows;
   }
+  async migrate(config) {
+    await migrate(
+      drizzle(this.queryClient(), { schema: juniorSqlSchema }),
+      config
+    );
+  }
   async transaction(callback) {
     const existingClient = this.transactionClient.getStore();
     if (existingClient) {
@@ -2037,6 +1771,16 @@ var NeonExecutor = class {
       client.release();
     }
   }
+  async withMigrationLock(migrationTable, callback) {
+    const client = await this.pool.connect();
+    const lockName = `junior:migrate:${migrationTable}`;
+    try {
+      await client.query("SELECT pg_advisory_lock(hashtext($1))", [lockName]);
+      return await callback();
+    } finally {
+      client.release(true);
+    }
+  }
   async close() {
     await this.pool.end();
   }
@@ -2057,6 +1801,7 @@ function createNeonJuniorSqlExecutor(args) {
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
 import pg from "pg";
 import { drizzle as drizzle2 } from "drizzle-orm/node-postgres";
+import { migrate as migrate2 } from "drizzle-orm/node-postgres/migrator";
 var { Pool: Pool2 } = pg;
 var PostgresExecutor = class {
   constructor(pool) {
@@ -2079,6 +1824,12 @@ var PostgresExecutor = class {
     ]);
     return result.rows;
   }
+  async migrate(config) {
+    await migrate2(
+      drizzle2(this.queryClient(), { schema: juniorSqlSchema }),
+      config
+    );
+  }
   async transaction(callback) {
     const existingClient = this.transactionClient.getStore();
     if (existingClient) {
@@ -2138,6 +1889,16 @@ var PostgresExecutor = class {
       client.release();
     }
   }
+  async withMigrationLock(migrationTable, callback) {
+    const client = await this.pool.connect();
+    const lockName = `junior:migrate:${migrationTable}`;
+    try {
+      await client.query("SELECT pg_advisory_lock(hashtext($1))", [lockName]);
+      return await callback();
+    } finally {
+      client.release(true);
+    }
+  }
   async close() {
     await this.pool.end();
   }
@@ -2222,8 +1983,8 @@ export {
   juniorConversations,
   juniorAgentSteps,
   juniorConversationMessages,
-  migrateSchema,
   createSqlStore,
+  piMessageSchema,
   legacyActorProvenance,
   instructionActors,
   readSessionLogEntries,