@sentry/junior 0.108.0 → 0.110.0

package/dist/{chunk-TE4QHJH4.js → chunk-4QU44P7Q.js}

@@ -1,239 +1,73 @@
+import {
+  createJuniorSqlExecutor,
+  juniorConversationEvents,
+  juniorConversations,
+  juniorIdentities,
+  juniorUsers
+} from "./chunk-JQFJO5WH.js";
 import {
   getChatConfig,
   modelProfileSchema
-} from "./chunk-SS67LUOK.js";
+} from "./chunk-WNOVRQ67.js";
 import {
-  juniorDestinations,
-  timestamptz
+  juniorDestinations
 } from "./chunk-VFUK3X5B.js";
-import {
-  parseDestination,
-  sameDestination
-} from "./chunk-B7PUBQQM.js";
 import {
   normalizeIdentityEmail
-} from "./chunk-O24R4DCK.js";
+} from "./chunk-IYKPU7H6.js";
+import {
+  parseSlackChannelReferenceId,
+  parseSlackTeamId
+} from "./chunk-42WRQLJ6.js";
 
 // src/chat/conversations/sql/store.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { and as and2, asc, desc, eq as eq2, isNull, sql as sql5 } from "drizzle-orm";
-
-// src/chat/identities/sql.ts
-import { randomUUID } from "crypto";
-import { and, eq, sql as sql4 } from "drizzle-orm";
-
-// src/db/schema/conversation-events.ts
-import {
-  foreignKey,
-  index as index3,
-  integer as integer2,
-  jsonb as jsonb3,
-  pgTable as pgTable4,
-  primaryKey,
-  text as text4,
-  uniqueIndex as uniqueIndex3
-} from "drizzle-orm/pg-core";
-import { sql as sql3 } from "drizzle-orm";
+import { and as and2, asc, desc, eq as eq2, isNull, sql as sql2 } from "drizzle-orm";
 
-// src/db/schema/conversations.ts
-import { sql as sql2 } from "drizzle-orm";
+// src/chat/destination.ts
 import {
-  index as index2,
-  integer,
-  jsonb as jsonb2,
-  pgTable as pgTable3,
-  text as text3
-} from "drizzle-orm/pg-core";
-
-// src/db/schema/identities.ts
-import { sql } from "drizzle-orm";
-import {
-  boolean,
-  index,
-  jsonb,
-  pgTable as pgTable2,
-  text as text2,
-  uniqueIndex as uniqueIndex2
-} from "drizzle-orm/pg-core";
-
-// src/db/schema/users.ts
-import { text, pgTable, uniqueIndex } from "drizzle-orm/pg-core";
-var juniorUsers = pgTable(
-  "junior_users",
-  {
-    id: text("id").primaryKey(),
-    primaryEmail: text("primary_email").notNull(),
-    primaryEmailNormalized: text("primary_email_normalized").notNull(),
-    displayName: text("display_name"),
-    createdAt: timestamptz("created_at").notNull(),
-    updatedAt: timestamptz("updated_at").notNull()
-  },
-  (table) => [
-    uniqueIndex("junior_users_primary_email_normalized_uidx").on(
-      table.primaryEmailNormalized
-    )
-  ]
-);
-
-// src/db/schema/identities.ts
-var juniorIdentities = pgTable2(
-  "junior_identities",
-  {
-    id: text2("id").primaryKey(),
-    kind: text2("kind").$type().notNull(),
-    provider: text2("provider").notNull(),
-    providerTenantId: text2("provider_tenant_id").notNull().default(""),
-    providerSubjectId: text2("provider_subject_id").notNull(),
-    displayName: text2("display_name"),
-    handle: text2("handle"),
-    email: text2("email"),
-    avatarUrl: text2("avatar_url"),
-    metadata: jsonb("metadata_json"),
-    createdAt: timestamptz("created_at").notNull(),
-    updatedAt: timestamptz("updated_at").notNull(),
-    userId: text2("user_id").references(() => juniorUsers.id),
-    emailNormalized: text2("email_normalized"),
-    emailVerified: boolean("email_verified").notNull().default(false)
-  },
-  (table) => [
-    uniqueIndex2("junior_identities_provider_subject_uidx").on(
-      table.provider,
-      table.providerTenantId,
-      table.providerSubjectId
-    ),
-    index("junior_identities_user_idx").on(table.userId),
-    index("junior_identities_verified_email_idx").on(table.emailNormalized).where(
-      sql`${table.emailVerified} = true AND ${table.emailNormalized} IS NOT NULL`
-    ),
-    index("junior_identities_kind_provider_idx").on(table.kind, table.provider)
-  ]
-);
-
-// src/db/schema/conversations.ts
-var juniorConversations = pgTable3(
-  "junior_conversations",
-  {
-    conversationId: text3("conversation_id").primaryKey(),
-    schemaVersion: integer("schema_version").notNull().default(1),
-    source: text3("source").$type(),
-    originType: text3("origin_type"),
-    originId: text3("origin_id"),
-    originRunId: text3("origin_run_id"),
-    destinationId: text3("destination_id").references(
-      () => juniorDestinations.id
-    ),
-    destination: jsonb2("destination_json").$type(),
-    actorIdentityId: text3("actor_identity_id").references(
-      () => juniorIdentities.id
-    ),
-    creatorIdentityId: text3("creator_identity_id").references(
-      () => juniorIdentities.id
-    ),
-    credentialSubjectIdentityId: text3(
-      "credential_subject_identity_id"
-    ).references(() => juniorIdentities.id),
-    actor: jsonb2("actor_json").$type(),
-    channelName: text3("channel_name"),
-    title: text3("title"),
-    createdAt: timestamptz("created_at").notNull(),
-    lastActivityAt: timestamptz("last_activity_at").notNull(),
-    updatedAt: timestamptz("updated_at").notNull(),
-    executionUpdatedAt: timestamptz("execution_updated_at"),
-    executionStatus: text3("execution_status").$type().notNull(),
-    runId: text3("run_id"),
-    lastCheckpointAt: timestamptz("last_checkpoint_at"),
-    lastEnqueuedAt: timestamptz("last_enqueued_at"),
-    // Subagent runs are child conversations; top-level listings filter
-    // parent_conversation_id IS NULL. Historical advisor children use this too.
-    parentConversationId: text3("parent_conversation_id").references(
-      () => juniorConversations.conversationId
-    ),
-    transcriptPurgedAt: timestamptz("transcript_purged_at"),
-    durationMs: integer("duration_ms").notNull().default(0),
-    usage: jsonb2("usage_json").$type(),
-    executionDurationMs: integer("execution_duration_ms").notNull().default(0),
-    executionUsage: jsonb2("execution_usage_json").$type(),
-    metricRunId: text3("metric_run_id"),
-    archivedAt: timestamptz("archived_at")
-  },
-  (table) => [
-    index2("junior_conversations_last_activity_idx").on(
-      table.lastActivityAt.desc(),
-      table.conversationId
-    ),
-    index2("junior_conversations_active_idx").using(
-      "btree",
-      sql2`coalesce(${table.executionUpdatedAt}, ${table.updatedAt})`,
-      table.conversationId
-    ).where(sql2`${table.executionStatus} <> 'idle'`),
-    index2("junior_conversations_destination_activity_idx").on(
-      table.destinationId,
-      table.lastActivityAt.desc()
-    ),
-    index2("junior_conversations_actor_activity_idx").on(
-      table.actorIdentityId,
-      table.lastActivityAt.desc()
-    ),
-    index2("junior_conversations_origin_idx").on(
-      table.originType,
-      table.originId,
-      table.lastActivityAt.desc()
-    ),
-    index2("junior_conversations_parent_idx").on(table.parentConversationId)
-  ]
-);
-
-// src/db/schema/conversation-events.ts
-var juniorConversationEvents = pgTable4(
-  "junior_conversation_events",
-  {
-    conversationId: text4("conversation_id").notNull(),
-    seq: integer2("seq").notNull(),
-    historyVersion: integer2("history_version").notNull(),
-    schemaVersion: integer2("schema_version").default(1).notNull(),
-    idempotencyKey: text4("idempotency_key"),
-    type: text4("type").notNull(),
-    payload: jsonb3("payload").$type().notNull(),
-    createdAt: timestamptz("created_at").notNull()
-  },
-  (table) => [
-    primaryKey({
-      name: "junior_conversation_events_conversation_id_seq_pk",
-      columns: [table.conversationId, table.seq]
-    }),
-    foreignKey({
-      name: "junior_conversation_events_conversation_id_junior_conversations_conversation_id_fk",
-      columns: [table.conversationId],
-      foreignColumns: [juniorConversations.conversationId]
-    }),
-    index3("junior_conversation_events_history_version_idx").on(
-      table.conversationId,
-      table.historyVersion,
-      table.seq
-    ),
-    index3("junior_conversation_events_type_idx").on(
-      table.conversationId,
-      table.type,
-      table.seq
-    ),
-    index3("junior_conversation_events_message_search_idx").using("gin", sql3`to_tsvector('english', ${table.payload}->>'text')`).where(sql3`${table.type} = 'message'`),
-    uniqueIndex3("junior_conversation_events_idempotency_idx").on(
-      table.conversationId,
-      table.idempotencyKey
-    )
-  ]
-);
-
-// src/db/schema.ts
-var juniorSqlSchema = {
-  juniorConversationEvents,
-  juniorConversations,
-  juniorDestinations,
-  juniorIdentities,
-  juniorUsers
-};
+  destinationSchema
+} from "@sentry/junior-plugin-api";
+function createSlackDestination(input) {
+  const channelId = parseSlackChannelReferenceId(input.channelId);
+  const teamId = parseSlackTeamId(input.teamId);
+  if (!channelId || !teamId) {
+    return void 0;
+  }
+  return { platform: "slack", teamId, channelId };
+}
+function parseDestination(value) {
+  const parsed = destinationSchema.safeParse(value);
+  return parsed.success ? parsed.data : void 0;
+}
+function requireSlackDestination(destination, action) {
+  if (destination?.platform === "slack") {
+    return destination;
+  }
+  throw new Error(`${action} requires a Slack destination`);
+}
+function sameDestination(left, right) {
+  if (left.platform !== right.platform) {
+    return false;
+  }
+  if (left.platform === "local" && right.platform === "local") {
+    return left.conversationId === right.conversationId;
+  }
+  if (left.platform === "slack" && right.platform === "slack") {
+    return left.teamId === right.teamId && left.channelId === right.channelId;
+  }
+  return false;
+}
+function destinationKey(destination) {
+  if (destination.platform === "local") {
+    return destination.conversationId;
+  }
+  return `slack:${destination.teamId}:${destination.channelId}`;
+}
 
 // src/chat/identities/sql.ts
+import { randomUUID } from "crypto";
+import { and, eq, sql } from "drizzle-orm";
 function dateFromMs(ms) {
   return new Date(ms);
 }
@@ -251,8 +85,8 @@ async function upsertUser(executor, args) {
   }).onConflictDoUpdate({
     target: juniorUsers.primaryEmailNormalized,
     set: {
-      displayName: sql4`coalesce(${juniorUsers.displayName}, excluded.display_name)`,
-      updatedAt: sql4`excluded.updated_at`
+      displayName: sql`coalesce(${juniorUsers.displayName}, excluded.display_name)`,
+      updatedAt: sql`excluded.updated_at`
     }
   }).returning({ id: juniorUsers.id });
   const id = rows[0]?.id;
@@ -313,16 +147,16 @@ async function upsertIdentity(executor, identity, nowMs = Date.now()) {
       juniorIdentities.providerSubjectId
     ],
     set: {
-      kind: sql4`excluded.kind`,
-      userId: sql4`coalesce(${juniorIdentities.userId}, excluded.user_id)`,
-      displayName: sql4`coalesce(${juniorIdentities.displayName}, excluded.display_name)`,
-      handle: sql4`coalesce(${juniorIdentities.handle}, excluded.handle)`,
-      email: sql4`case when ${juniorIdentities.emailVerified} then coalesce(${juniorIdentities.email}, excluded.email) when excluded.email_verified then excluded.email else coalesce(${juniorIdentities.email}, excluded.email) end`,
-      emailNormalized: sql4`case when ${juniorIdentities.emailVerified} then coalesce(${juniorIdentities.emailNormalized}, excluded.email_normalized) when excluded.email_verified then excluded.email_normalized else coalesce(${juniorIdentities.emailNormalized}, excluded.email_normalized) end`,
-      emailVerified: sql4`${juniorIdentities.emailVerified} OR excluded.email_verified`,
-      avatarUrl: sql4`coalesce(${juniorIdentities.avatarUrl}, excluded.avatar_url)`,
-      metadata: sql4`coalesce(${juniorIdentities.metadata}, excluded.metadata_json)`,
-      updatedAt: sql4`excluded.updated_at`
+      kind: sql`excluded.kind`,
+      userId: sql`coalesce(${juniorIdentities.userId}, excluded.user_id)`,
+      displayName: sql`coalesce(${juniorIdentities.displayName}, excluded.display_name)`,
+      handle: sql`coalesce(${juniorIdentities.handle}, excluded.handle)`,
+      email: sql`case when ${juniorIdentities.emailVerified} then coalesce(${juniorIdentities.email}, excluded.email) when excluded.email_verified then excluded.email else coalesce(${juniorIdentities.email}, excluded.email) end`,
+      emailNormalized: sql`case when ${juniorIdentities.emailVerified} then coalesce(${juniorIdentities.emailNormalized}, excluded.email_normalized) when excluded.email_verified then excluded.email_normalized else coalesce(${juniorIdentities.emailNormalized}, excluded.email_normalized) end`,
+      emailVerified: sql`${juniorIdentities.emailVerified} OR excluded.email_verified`,
+      avatarUrl: sql`coalesce(${juniorIdentities.avatarUrl}, excluded.avatar_url)`,
+      metadata: sql`coalesce(${juniorIdentities.metadata}, excluded.metadata_json)`,
+      updatedAt: sql`excluded.updated_at`
     }
   }).returning({
     id: juniorIdentities.id,
@@ -712,63 +546,6 @@ var SqlStore = class {
       }
     });
   }
-  /** 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,
-      async () => {
-        const existing = await this.get({
-          conversationId: conversation.conversationId
-        });
-        const sourceExecutionAtMs = conversation.execution.updatedAtMs ?? conversation.updatedAtMs;
-        const existingExecutionAtMs = existing === void 0 ? void 0 : existing.execution.updatedAtMs ?? existing.updatedAtMs;
-        const refreshExecutionFromSource = existingExecutionAtMs === void 0 || sourceExecutionAtMs >= existingExecutionAtMs;
-        const mergedConversation = existing ? {
-          ...conversation,
-          channelName: existing.channelName ?? conversation.channelName,
-          createdAtMs: Math.min(
-            existing.createdAtMs,
-            conversation.createdAtMs
-          ),
-          destination: existing.destination ?? conversation.destination,
-          lastActivityAtMs: Math.max(
-            existing.lastActivityAtMs,
-            conversation.lastActivityAtMs
-          ),
-          actor: existing.actor ?? conversation.actor,
-          source: existing.source ?? conversation.source,
-          title: existing.title ?? conversation.title,
-          updatedAtMs: Math.max(
-            existing.updatedAtMs,
-            conversation.updatedAtMs
-          ),
-          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 ? {
-              metricRunId: conversation.execution.runId ?? null,
-              executionDurationMs: metrics.executionDurationMs,
-              executionUsage: metrics.executionUsage ?? null
-            } : {}
-          }).where(
-            and2(
-              eq2(
-                juniorConversations.conversationId,
-                conversation.conversationId
-              ),
-              eq2(juniorConversations.durationMs, 0),
-              isNull(juniorConversations.usage)
-            )
-          );
-        }
-      }
-    );
-  }
   async listByActivity(args = {}) {
     const rows = await this.executor.db().select({
       conversation: juniorConversations,
@@ -838,9 +615,9 @@ var SqlStore = class {
   /** Upsert the conversation row while preserving previously discovered nullable metadata fields. */
   async upsertConversation(args) {
     const { conversation } = args;
-    const incomingExecutionVersion = sql5`coalesce(excluded.execution_updated_at, excluded.updated_at)`;
-    const currentExecutionVersion = sql5`coalesce(${juniorConversations.executionUpdatedAt}, ${juniorConversations.updatedAt})`;
-    const incomingExecutionIsFresh = sql5`${incomingExecutionVersion} >= ${currentExecutionVersion}`;
+    const incomingExecutionVersion = sql2`coalesce(excluded.execution_updated_at, excluded.updated_at)`;
+    const currentExecutionVersion = sql2`coalesce(${juniorConversations.executionUpdatedAt}, ${juniorConversations.updatedAt})`;
+    const incomingExecutionIsFresh = sql2`${incomingExecutionVersion} >= ${currentExecutionVersion}`;
     const destinationId = await this.upsertDestination(
       destinationUpsertFromDestination({
         channelName: conversation.channelName,
@@ -856,7 +633,12 @@ var SqlStore = class {
       actorIdentityObservation,
       conversation.updatedAtMs
     ) : void 0;
-    await this.executor.db().insert(juniorConversations).values({
+    const rootConversationId = conversation.lineage ? sql2`(
+          select parent.root_conversation_id
+          from junior_conversations parent
+          where parent.conversation_id = ${conversation.lineage.parentConversationId}
+        )` : conversation.conversationId;
+    const rows = await this.executor.db().insert(juniorConversations).values({
       conversationId: conversation.conversationId,
       schemaVersion: 1,
       source: conversation.source ?? null,
@@ -879,36 +661,43 @@ var SqlStore = class {
       runId: conversation.execution.runId ?? null,
       lastCheckpointAt: conversation.execution.lastCheckpointAtMs === void 0 ? null : dateFromMs2(conversation.execution.lastCheckpointAtMs),
       lastEnqueuedAt: conversation.execution.lastEnqueuedAtMs === void 0 ? null : dateFromMs2(conversation.execution.lastEnqueuedAtMs),
-      parentConversationId: conversation.lineage?.parentConversationId ?? null
+      parentConversationId: conversation.lineage?.parentConversationId ?? null,
+      rootConversationId
     }).onConflictDoUpdate({
       target: juniorConversations.conversationId,
       set: {
-        source: sql5`coalesce(excluded.source, ${juniorConversations.source})`,
-        originType: sql5`coalesce(excluded.origin_type, ${juniorConversations.originType})`,
-        originId: sql5`coalesce(excluded.origin_id, ${juniorConversations.originId})`,
-        originRunId: sql5`coalesce(excluded.origin_run_id, ${juniorConversations.originRunId})`,
-        destinationId: sql5`coalesce(excluded.destination_id, ${juniorConversations.destinationId})`,
-        actorIdentityId: sql5`coalesce(excluded.actor_identity_id, ${juniorConversations.actorIdentityId})`,
-        creatorIdentityId: sql5`coalesce(excluded.creator_identity_id, ${juniorConversations.creatorIdentityId})`,
-        credentialSubjectIdentityId: sql5`coalesce(excluded.credential_subject_identity_id, ${juniorConversations.credentialSubjectIdentityId})`,
-        channelName: sql5`coalesce(excluded.channel_name, ${juniorConversations.channelName})`,
-        title: sql5`coalesce(excluded.title, ${juniorConversations.title})`,
-        createdAt: sql5`least(${juniorConversations.createdAt}, excluded.created_at)`,
-        lastActivityAt: sql5`greatest(${juniorConversations.lastActivityAt}, excluded.last_activity_at)`,
-        updatedAt: sql5`greatest(${juniorConversations.updatedAt}, excluded.updated_at)`,
-        executionUpdatedAt: sql5`case when ${incomingExecutionIsFresh} then excluded.execution_updated_at else ${juniorConversations.executionUpdatedAt} end`,
-        executionStatus: sql5`case when ${incomingExecutionIsFresh} then excluded.execution_status else ${juniorConversations.executionStatus} end`,
-        runId: sql5`case when ${incomingExecutionIsFresh} then excluded.run_id else ${juniorConversations.runId} end`,
-        lastCheckpointAt: sql5`case when ${incomingExecutionIsFresh} then coalesce(excluded.last_checkpoint_at, ${juniorConversations.lastCheckpointAt}) else ${juniorConversations.lastCheckpointAt} end`,
-        lastEnqueuedAt: sql5`case when ${incomingExecutionIsFresh} then coalesce(excluded.last_enqueued_at, ${juniorConversations.lastEnqueuedAt}) else ${juniorConversations.lastEnqueuedAt} end`
+        source: sql2`coalesce(excluded.source, ${juniorConversations.source})`,
+        originType: sql2`coalesce(excluded.origin_type, ${juniorConversations.originType})`,
+        originId: sql2`coalesce(excluded.origin_id, ${juniorConversations.originId})`,
+        originRunId: sql2`coalesce(excluded.origin_run_id, ${juniorConversations.originRunId})`,
+        destinationId: sql2`coalesce(excluded.destination_id, ${juniorConversations.destinationId})`,
+        actorIdentityId: sql2`coalesce(excluded.actor_identity_id, ${juniorConversations.actorIdentityId})`,
+        creatorIdentityId: sql2`coalesce(excluded.creator_identity_id, ${juniorConversations.creatorIdentityId})`,
+        credentialSubjectIdentityId: sql2`coalesce(excluded.credential_subject_identity_id, ${juniorConversations.credentialSubjectIdentityId})`,
+        channelName: sql2`coalesce(excluded.channel_name, ${juniorConversations.channelName})`,
+        title: sql2`coalesce(excluded.title, ${juniorConversations.title})`,
+        createdAt: sql2`least(${juniorConversations.createdAt}, excluded.created_at)`,
+        lastActivityAt: sql2`greatest(${juniorConversations.lastActivityAt}, excluded.last_activity_at)`,
+        updatedAt: sql2`greatest(${juniorConversations.updatedAt}, excluded.updated_at)`,
+        executionUpdatedAt: sql2`case when ${incomingExecutionIsFresh} then excluded.execution_updated_at else ${juniorConversations.executionUpdatedAt} end`,
+        executionStatus: sql2`case when ${incomingExecutionIsFresh} then excluded.execution_status else ${juniorConversations.executionStatus} end`,
+        runId: sql2`case when ${incomingExecutionIsFresh} then excluded.run_id else ${juniorConversations.runId} end`,
+        lastCheckpointAt: sql2`case when ${incomingExecutionIsFresh} then coalesce(excluded.last_checkpoint_at, ${juniorConversations.lastCheckpointAt}) else ${juniorConversations.lastCheckpointAt} end`,
+        lastEnqueuedAt: sql2`case when ${incomingExecutionIsFresh} then coalesce(excluded.last_enqueued_at, ${juniorConversations.lastEnqueuedAt}) else ${juniorConversations.lastEnqueuedAt} end`,
+        rootConversationId: sql2`coalesce(${juniorConversations.rootConversationId}, excluded.root_conversation_id)`
       }
+    }).returning({
+      rootConversationId: juniorConversations.rootConversationId
     });
+    if (!rows[0]?.rootConversationId) {
+      throw new Error("Conversation parent is missing its persisted root");
+    }
   }
   async upsertDestination(destination, nowMs) {
     if (!destination) {
       return void 0;
     }
-    const visibilityUpdate = destination.refreshVisibility ? sql5`excluded.visibility` : juniorDestinations.visibility;
+    const visibilityUpdate = destination.refreshVisibility ? sql2`excluded.visibility` : juniorDestinations.visibility;
     const rows = await this.executor.db().insert(juniorDestinations).values({
       id: randomUUID2(),
       provider: destination.provider,
@@ -928,14 +717,14 @@ var SqlStore = class {
         juniorDestinations.providerDestinationId
       ],
       set: {
-        kind: sql5`excluded.kind`,
-        displayName: sql5`coalesce(excluded.display_name, ${juniorDestinations.displayName})`,
+        kind: sql2`excluded.kind`,
+        displayName: sql2`coalesce(excluded.display_name, ${juniorDestinations.displayName})`,
         // Signal-less writes insert as private but must not clobber an
         // existing public/private value. Live source signals refresh this
         // field so converted channels converge on the next message.
         visibility: visibilityUpdate,
-        metadata: sql5`coalesce(excluded.metadata_json, ${juniorDestinations.metadata})`,
-        updatedAt: sql5`excluded.updated_at`
+        metadata: sql2`coalesce(excluded.metadata_json, ${juniorDestinations.metadata})`,
+        updatedAt: sql2`excluded.updated_at`
       }
     }).returning({ id: juniorDestinations.id });
     return rows[0]?.id;
@@ -955,7 +744,7 @@ import {
   inArray,
   isNotNull,
   lte,
-  sql as sql7
+  sql as sql4
 } from "drizzle-orm";
 
 // src/chat/conversations/history.ts
@@ -1025,6 +814,7 @@ var historyReplacementEventDataSchema = z2.discriminatedUnion("type", [
     type: z2.literal("handoff"),
     modelProfile: handoffModelProfileSchema,
     modelId: z2.string().min(1),
+    reasoningLevel: z2.string().min(1).optional(),
     triggeringToolCallId: z2.string().min(1).optional(),
     replacementHistory: replacementHistorySchema
   }).strict(),
@@ -1244,7 +1034,7 @@ var newConversationEventSchema = z2.object({
 }).strict();
 
 // src/chat/conversations/sql/conversation-row.ts
-import { sql as sql6 } from "drizzle-orm";
+import { sql as sql3 } from "drizzle-orm";
 async function ensureConversationRow(executor, conversationId, atMs) {
   const at = new Date(atMs);
   await executor.db().insert(juniorConversations).values({
@@ -1256,8 +1046,8 @@ async function ensureConversationRow(executor, conversationId, atMs) {
   }).onConflictDoUpdate({
     target: juniorConversations.conversationId,
     set: {
-      lastActivityAt: sql6`greatest(${juniorConversations.lastActivityAt}, excluded.last_activity_at)`,
-      updatedAt: sql6`greatest(${juniorConversations.updatedAt}, excluded.updated_at)`,
+      lastActivityAt: sql3`greatest(${juniorConversations.lastActivityAt}, excluded.last_activity_at)`,
+      updatedAt: sql3`greatest(${juniorConversations.updatedAt}, excluded.updated_at)`,
       transcriptPurgedAt: null
     }
   });
@@ -1471,8 +1261,8 @@ var SqlConversationEventStore = class {
   /** Read the next sequence and active model-history version. */
   async readCursor(conversationId) {
     const rows = await this.executor.db().select({
-      maxSeq: sql7`max(${juniorConversationEvents.seq})`,
-      maxHistoryVersion: sql7`max(${juniorConversationEvents.historyVersion})`
+      maxSeq: sql4`max(${juniorConversationEvents.seq})`,
+      maxHistoryVersion: sql4`max(${juniorConversationEvents.historyVersion})`
     }).from(juniorConversationEvents).where(eq3(juniorConversationEvents.conversationId, conversationId));
     const maxSeq = rows[0]?.maxSeq;
     const maxHistoryVersion = rows[0]?.maxHistoryVersion;
@@ -1487,7 +1277,7 @@ function createSqlConversationEventStore(executor) {
 }
 
 // src/chat/conversations/sql/search.ts
-import { and as and4, desc as desc3, eq as eq4, isNull as isNull2, ne, sql as sql8 } from "drizzle-orm";
+import { and as and4, desc as desc3, eq as eq4, isNull as isNull2, ne, sql as sql5 } from "drizzle-orm";
 var SqlConversationSearchStore = class {
   constructor(executor) {
     this.executor = executor;
@@ -1495,12 +1285,12 @@ var SqlConversationSearchStore = class {
   executor;
   async search(args) {
     const db = this.executor.db();
-    const tsquery = sql8`websearch_to_tsquery('english', ${args.query})`;
-    const text5 = sql8`${juniorConversationEvents.payload}->>'text'`;
-    const rank = sql8`ts_rank_cd(to_tsvector('english', ${text5}), ${tsquery})`;
-    const excerpt = sql8`ts_headline('english', ${text5}, ${tsquery}, 'MaxFragments=2, MinWords=8, MaxWords=40, FragmentDelimiter=" … ", StartSel=**, StopSel=**')`;
-    const role = sql8`${juniorConversationEvents.payload}->>'role'`;
-    const messageId = sql8`${juniorConversationEvents.payload}->>'messageId'`;
+    const tsquery = sql5`websearch_to_tsquery('english', ${args.query})`;
+    const text = sql5`${juniorConversationEvents.payload}->>'text'`;
+    const rank = sql5`ts_rank_cd(to_tsvector('english', ${text}), ${tsquery})`;
+    const excerpt = sql5`ts_headline('english', ${text}, ${tsquery}, 'MaxFragments=2, MinWords=8, MaxWords=40, FragmentDelimiter=" … ", StartSel=**, StopSel=**')`;
+    const role = sql5`${juniorConversationEvents.payload}->>'role'`;
+    const messageId = sql5`${juniorConversationEvents.payload}->>'messageId'`;
     const bestPerConversation = db.selectDistinctOn([juniorConversations.conversationId], {
       conversationId: juniorConversations.conversationId,
       excerpt: excerpt.as("excerpt"),
@@ -1529,8 +1319,8 @@ var SqlConversationSearchStore = class {
         eq4(juniorDestinations.providerTenantId, args.scope.providerTenantId),
         eq4(juniorDestinations.visibility, "public"),
         eq4(juniorConversationEvents.type, "message"),
-        sql8`${role} in ('user', 'assistant')`,
-        sql8`to_tsvector('english', ${text5}) @@ ${tsquery}`
+        sql5`${role} in ('user', 'assistant')`,
+        sql5`to_tsvector('english', ${text}) @@ ${tsquery}`
       )
     ).orderBy(
       juniorConversations.conversationId,
@@ -1555,252 +1345,6 @@ function createSqlConversationSearchStore(executor) {
   return new SqlConversationSearchStore(executor);
 }
 
-// src/db/neon.ts
-import { AsyncLocalStorage } from "async_hooks";
-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;
-  }
-  pool;
-  transactionClient = new AsyncLocalStorage();
-  savepointId = 0;
-  db() {
-    return drizzle(this.queryClient(), {
-      schema: juniorSqlSchema
-    });
-  }
-  async execute(statement, params = []) {
-    await this.queryClient().query(statement, [...params]);
-  }
-  async query(statement, params = []) {
-    const result = await this.queryClient().query(statement, [
-      ...params
-    ]);
-    return result.rows;
-  }
-  async migrate(config) {
-    await migrate(
-      drizzle(this.queryClient(), { schema: juniorSqlSchema }),
-      config
-    );
-  }
-  async transaction(callback) {
-    const existingClient = this.transactionClient.getStore();
-    if (existingClient) {
-      const savepoint = `junior_savepoint_${++this.savepointId}`;
-      await existingClient.query(`SAVEPOINT ${savepoint}`);
-      try {
-        const result = await callback();
-        await existingClient.query(`RELEASE SAVEPOINT ${savepoint}`);
-        return result;
-      } catch (error) {
-        await existingClient.query(`ROLLBACK TO SAVEPOINT ${savepoint}`);
-        await existingClient.query(`RELEASE SAVEPOINT ${savepoint}`);
-        throw error;
-      }
-    }
-    const client = await this.pool.connect();
-    try {
-      await client.query("BEGIN");
-      const result = await this.transactionClient.run(client, callback);
-      await client.query("COMMIT");
-      return result;
-    } catch (error) {
-      await client.query("ROLLBACK");
-      throw error;
-    } finally {
-      client.release();
-    }
-  }
-  async withLock(lockName, callback) {
-    if (!lockName) {
-      throw new Error("SQL lock name is required");
-    }
-    const existingClient = this.transactionClient.getStore();
-    if (existingClient) {
-      await existingClient.query("SELECT pg_advisory_xact_lock(hashtext($1))", [
-        lockName
-      ]);
-      return await callback();
-    }
-    const client = await this.pool.connect();
-    try {
-      await client.query("BEGIN");
-      return await this.transactionClient.run(client, async () => {
-        try {
-          await client.query("SELECT pg_advisory_xact_lock(hashtext($1))", [
-            lockName
-          ]);
-          const result = await callback();
-          await client.query("COMMIT");
-          return result;
-        } catch (error) {
-          await client.query("ROLLBACK");
-          throw error;
-        }
-      });
-    } finally {
-      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();
-  }
-  queryClient() {
-    return this.transactionClient.getStore() ?? this.pool;
-  }
-};
-function createNeonJuniorSqlExecutor(args) {
-  return new NeonExecutor(
-    new Pool({
-      connectionString: args.connectionString,
-      max: 3
-    })
-  );
-}
-
-// src/db/postgres.ts
-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) {
-    this.pool = pool;
-  }
-  pool;
-  transactionClient = new AsyncLocalStorage2();
-  savepointId = 0;
-  db() {
-    return drizzle2(this.queryClient(), {
-      schema: juniorSqlSchema
-    });
-  }
-  async execute(statement, params = []) {
-    await this.queryClient().query(statement, [...params]);
-  }
-  async query(statement, params = []) {
-    const result = await this.queryClient().query(statement, [
-      ...params
-    ]);
-    return result.rows;
-  }
-  async migrate(config) {
-    await migrate2(
-      drizzle2(this.queryClient(), { schema: juniorSqlSchema }),
-      config
-    );
-  }
-  async transaction(callback) {
-    const existingClient = this.transactionClient.getStore();
-    if (existingClient) {
-      const savepoint = `junior_savepoint_${++this.savepointId}`;
-      await existingClient.query(`SAVEPOINT ${savepoint}`);
-      try {
-        const result = await callback();
-        await existingClient.query(`RELEASE SAVEPOINT ${savepoint}`);
-        return result;
-      } catch (error) {
-        await existingClient.query(`ROLLBACK TO SAVEPOINT ${savepoint}`);
-        await existingClient.query(`RELEASE SAVEPOINT ${savepoint}`);
-        throw error;
-      }
-    }
-    const client = await this.pool.connect();
-    try {
-      await client.query("BEGIN");
-      const result = await this.transactionClient.run(client, callback);
-      await client.query("COMMIT");
-      return result;
-    } catch (error) {
-      await client.query("ROLLBACK");
-      throw error;
-    } finally {
-      client.release();
-    }
-  }
-  async withLock(lockName, callback) {
-    if (!lockName) {
-      throw new Error("SQL lock name is required");
-    }
-    const existingClient = this.transactionClient.getStore();
-    if (existingClient) {
-      await existingClient.query("SELECT pg_advisory_xact_lock(hashtext($1))", [
-        lockName
-      ]);
-      return await callback();
-    }
-    const client = await this.pool.connect();
-    try {
-      await client.query("BEGIN");
-      return await this.transactionClient.run(client, async () => {
-        try {
-          await client.query("SELECT pg_advisory_xact_lock(hashtext($1))", [
-            lockName
-          ]);
-          const result = await callback();
-          await client.query("COMMIT");
-          return result;
-        } catch (error) {
-          await client.query("ROLLBACK");
-          throw error;
-        }
-      });
-    } finally {
-      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();
-  }
-  queryClient() {
-    return this.transactionClient.getStore() ?? this.pool;
-  }
-};
-function createPostgresJuniorSqlExecutor(args) {
-  return new PostgresExecutor(
-    new Pool2({
-      application_name: args.applicationName,
-      connectionString: args.connectionString,
-      max: 3
-    })
-  );
-}
-
-// src/db/executor.ts
-function createJuniorSqlExecutor(args) {
-  if (args.driver === "postgres") {
-    return createPostgresJuniorSqlExecutor(args);
-  }
-  return createNeonJuniorSqlExecutor(args);
-}
-
 // src/chat/db.ts
 var current;
 function createDb(args) {
@@ -1810,20 +1354,20 @@ function createDb(args) {
   });
 }
 function getSqlExecutor() {
-  const { sql: sql9 } = getChatConfig();
-  if (current?.databaseUrl !== sql9.databaseUrl || current.driver !== sql9.driver) {
+  const { sql: sql6 } = getChatConfig();
+  if (current?.databaseUrl !== sql6.databaseUrl || current.driver !== sql6.driver) {
     if (current) {
       const previous = current;
       current = void 0;
       void previous.db.close().catch(() => void 0);
     }
     const db = createDb({
-      databaseUrl: sql9.databaseUrl,
-      driver: sql9.driver
+      databaseUrl: sql6.databaseUrl,
+      driver: sql6.driver
     });
     current = {
-      databaseUrl: sql9.databaseUrl,
-      driver: sql9.driver,
+      databaseUrl: sql6.databaseUrl,
+      driver: sql6.driver,
       db,
       store: createSqlStore(db),
       eventStore: createSqlConversationEventStore(db),
@@ -1854,22 +1398,18 @@ async function closeDb() {
 }
 
 export {
-  juniorUsers,
-  juniorIdentities,
-  juniorConversations,
-  juniorConversationEvents,
-  createSqlStore,
-  conversationMessageProvenanceSchema,
+  createSlackDestination,
+  parseDestination,
+  requireSlackDestination,
+  sameDestination,
+  destinationKey,
   instructionProvenanceFor,
   contextProvenance,
   instructionActors,
-  conversationEventDataSchema,
   decodeStoredConversationEvent,
-  newConversationEventSchema,
   sanitizePostgresJson,
   withConversationEventLock,
   createSqlConversationEventStore,
-  createJuniorSqlExecutor,
   getSqlExecutor,
   getDb,
   getConversationStore,