@sentry/junior 0.87.0 → 0.89.0

package/dist/{chunk-6I6HBOQM.js → chunk-4IXHIV37.js}

@@ -1,25 +1,28 @@
 import {
   parseDestination,
   sameDestination
-} from "./chunk-GGD6WK6V.js";
+} from "./chunk-AHLSXMOU.js";
 import {
   getChatConfig
-} from "./chunk-ZU2ALUVQ.js";
+} from "./chunk-S35CPNPT.js";
 import {
   parseStoredSlackRequester
-} from "./chunk-IXTBFABZ.js";
+} from "./chunk-KQKIA4CU.js";
+import {
+  normalizeIdentityEmail
+} from "./chunk-VMBZFPZM.js";
 
 // src/chat/conversations/sql/store.ts
-import { randomUUID } from "crypto";
-import { and, asc, desc, eq, sql as sql2 } from "drizzle-orm";
+import { randomUUID as randomUUID2 } from "crypto";
+import { and as and2, asc, desc, eq as eq2, sql as sql4 } from "drizzle-orm";
 
-// src/chat/conversations/sql/migrations.ts
-import { createHash } from "crypto";
-import { z } from "zod";
+// src/chat/identities/sql.ts
+import { randomUUID } from "crypto";
+import { and, eq, sql as sql3 } from "drizzle-orm";
 
 // src/chat/conversations/sql/schema/conversations.ts
-import { sql } from "drizzle-orm";
-import { index as index3, integer, jsonb as jsonb3, pgTable as pgTable3, text as text3 } from "drizzle-orm/pg-core";
+import { sql as sql2 } from "drizzle-orm";
+import { index as index3, integer, jsonb as jsonb3, pgTable as pgTable4, text as text4 } from "drizzle-orm/pg-core";
 
 // src/chat/conversations/sql/schema/destinations.ts
 import { index, jsonb, pgTable, text, uniqueIndex } from "drizzle-orm/pg-core";
@@ -58,68 +61,104 @@ var juniorDestinations = pgTable(
 );
 
 // src/chat/conversations/sql/schema/identities.ts
-import { index as index2, jsonb as jsonb2, pgTable as pgTable2, text as text2, uniqueIndex as uniqueIndex2 } from "drizzle-orm/pg-core";
-var juniorIdentities = pgTable2(
-  "junior_identities",
+import { sql } from "drizzle-orm";
+import {
+  boolean,
+  index as index2,
+  jsonb as jsonb2,
+  pgTable as pgTable3,
+  text as text3,
+  uniqueIndex as uniqueIndex3
+} from "drizzle-orm/pg-core";
+
+// src/chat/conversations/sql/schema/users.ts
+import { text as text2, pgTable as pgTable2, uniqueIndex as uniqueIndex2 } from "drizzle-orm/pg-core";
+var juniorUsers = pgTable2(
+  "junior_users",
   {
     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(),
+    primaryEmail: text2("primary_email").notNull(),
+    primaryEmailNormalized: text2("primary_email_normalized").notNull(),
     displayName: text2("display_name"),
-    handle: text2("handle"),
-    email: text2("email"),
-    avatarUrl: text2("avatar_url"),
-    metadata: jsonb2("metadata_json"),
     createdAt: timestamptz("created_at").notNull(),
     updatedAt: timestamptz("updated_at").notNull()
   },
   (table) => [
-    uniqueIndex2("junior_identities_provider_subject_uidx").on(
+    uniqueIndex2("junior_users_primary_email_normalized_uidx").on(
+      table.primaryEmailNormalized
+    )
+  ]
+);
+
+// src/chat/conversations/sql/schema/identities.ts
+var juniorIdentities = pgTable3(
+  "junior_identities",
+  {
+    id: text3("id").primaryKey(),
+    kind: text3("kind").$type().notNull(),
+    provider: text3("provider").notNull(),
+    providerTenantId: text3("provider_tenant_id").notNull().default(""),
+    providerSubjectId: text3("provider_subject_id").notNull(),
+    displayName: text3("display_name"),
+    handle: text3("handle"),
+    email: text3("email"),
+    avatarUrl: text3("avatar_url"),
+    metadata: jsonb2("metadata_json"),
+    createdAt: timestamptz("created_at").notNull(),
+    updatedAt: timestamptz("updated_at").notNull(),
+    userId: text3("user_id").references(() => juniorUsers.id),
+    emailNormalized: text3("email_normalized"),
+    emailVerified: boolean("email_verified").notNull().default(false)
+  },
+  (table) => [
+    uniqueIndex3("junior_identities_provider_subject_uidx").on(
       table.provider,
       table.providerTenantId,
       table.providerSubjectId
     ),
+    index2("junior_identities_user_idx").on(table.userId),
+    index2("junior_identities_verified_email_idx").on(table.emailNormalized).where(
+      sql`${table.emailVerified} = true AND ${table.emailNormalized} IS NOT NULL`
+    ),
     index2("junior_identities_kind_provider_idx").on(table.kind, table.provider)
   ]
 );
 
 // src/chat/conversations/sql/schema/conversations.ts
-var juniorConversations = pgTable3(
+var juniorConversations = pgTable4(
   "junior_conversations",
   {
-    conversationId: text3("conversation_id").primaryKey(),
+    conversationId: text4("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(
+    source: text4("source").$type(),
+    originType: text4("origin_type"),
+    originId: text4("origin_id"),
+    originRunId: text4("origin_run_id"),
+    destinationId: text4("destination_id").references(
       () => juniorDestinations.id
     ),
     destination: jsonb3("destination_json").$type(),
-    actorIdentityId: text3("actor_identity_id").references(
+    actorIdentityId: text4("actor_identity_id").references(
       () => juniorIdentities.id
     ),
-    requesterIdentityId: text3("requester_identity_id").references(
+    requesterIdentityId: text4("requester_identity_id").references(
       () => juniorIdentities.id
     ),
-    creatorIdentityId: text3("creator_identity_id").references(
+    creatorIdentityId: text4("creator_identity_id").references(
       () => juniorIdentities.id
     ),
-    credentialSubjectIdentityId: text3(
+    credentialSubjectIdentityId: text4(
       "credential_subject_identity_id"
     ).references(() => juniorIdentities.id),
     requester: jsonb3("requester_json").$type(),
-    channelName: text3("channel_name"),
-    title: text3("title"),
+    channelName: text4("channel_name"),
+    title: text4("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"),
+    executionStatus: text4("execution_status").$type().notNull(),
+    runId: text4("run_id"),
     lastCheckpointAt: timestamptz("last_checkpoint_at"),
     lastEnqueuedAt: timestamptz("last_enqueued_at")
   },
@@ -130,9 +169,9 @@ var juniorConversations = pgTable3(
     ),
     index3("junior_conversations_active_idx").using(
       "btree",
-      sql`coalesce(${table.executionUpdatedAt}, ${table.updatedAt})`,
+      sql2`coalesce(${table.executionUpdatedAt}, ${table.updatedAt})`,
       table.conversationId
-    ).where(sql`${table.executionStatus} <> 'idle'`),
+    ).where(sql2`${table.executionStatus} <> 'idle'`),
     index3("junior_conversations_destination_activity_idx").on(
       table.destinationId,
       table.lastActivityAt.desc()
@@ -154,10 +193,10 @@ var juniorConversations = pgTable3(
 );
 
 // src/chat/conversations/sql/schema/migrations.ts
-import { pgTable as pgTable4, text as text4 } from "drizzle-orm/pg-core";
-var juniorSchemaMigrations = pgTable4("junior_schema_migrations", {
-  id: text4("id").primaryKey(),
-  checksum: text4("checksum").notNull(),
+import { pgTable as pgTable5, text as text5 } from "drizzle-orm/pg-core";
+var juniorSchemaMigrations = pgTable5("junior_schema_migrations", {
+  id: text5("id").primaryKey(),
+  checksum: text5("checksum").notNull(),
   appliedAt: timestamptz("applied_at").notNull().defaultNow()
 });
 
@@ -166,10 +205,123 @@ var schema = {
   juniorConversations,
   juniorDestinations,
   juniorIdentities,
-  juniorSchemaMigrations
+  juniorSchemaMigrations,
+  juniorUsers
 };
 
+// src/chat/sql/schema.ts
+var juniorSqlSchema = {
+  ...schema
+};
+
+// src/chat/identities/sql.ts
+function dateFromMs(ms) {
+  return new Date(ms);
+}
+function tenantId(value) {
+  return value ?? "";
+}
+async function upsertUser(executor, args) {
+  const rows = await executor.db().insert(juniorUsers).values({
+    id: randomUUID(),
+    primaryEmail: args.email,
+    primaryEmailNormalized: args.emailNormalized,
+    displayName: args.displayName ?? null,
+    createdAt: dateFromMs(args.nowMs),
+    updatedAt: dateFromMs(args.nowMs)
+  }).onConflictDoUpdate({
+    target: juniorUsers.primaryEmailNormalized,
+    set: {
+      displayName: sql3`coalesce(${juniorUsers.displayName}, excluded.display_name)`,
+      updatedAt: sql3`excluded.updated_at`
+    }
+  }).returning({ id: juniorUsers.id });
+  const id = rows[0]?.id;
+  if (!id) {
+    throw new Error("User identity upsert returned no row");
+  }
+  return id;
+}
+async function existingIdentity(executor, identity) {
+  const rows = await executor.db().select().from(juniorIdentities).where(
+    and(
+      eq(juniorIdentities.provider, identity.provider),
+      eq(
+        juniorIdentities.providerTenantId,
+        tenantId(identity.providerTenantId)
+      ),
+      eq(juniorIdentities.providerSubjectId, identity.providerSubjectId)
+    )
+  );
+  return rows[0];
+}
+async function upsertIdentity(executor, identity, nowMs = Date.now()) {
+  const emailNormalized = normalizeIdentityEmail(identity.email);
+  const email = emailNormalized ? identity.email?.trim() || emailNormalized : void 0;
+  const existing = await existingIdentity(executor, identity);
+  const userEmailNormalized = existing?.emailVerified && existing.emailNormalized ? existing.emailNormalized : identity.emailVerified ? emailNormalized : void 0;
+  const userEmail = existing?.emailVerified && existing.email ? existing.email : email ?? userEmailNormalized;
+  const verifiedUserId = identity.kind === "user" && userEmailNormalized ? await upsertUser(executor, {
+    email: userEmail ?? userEmailNormalized,
+    emailNormalized: userEmailNormalized,
+    nowMs,
+    ...existing?.displayName || identity.displayName ? { displayName: existing?.displayName ?? identity.displayName } : {}
+  }) : void 0;
+  if (existing?.userId && verifiedUserId && existing.userId !== verifiedUserId) {
+    throw new Error("Identity verified email conflicts with linked user");
+  }
+  const userId = existing?.userId ?? verifiedUserId;
+  const rows = await executor.db().insert(juniorIdentities).values({
+    id: randomUUID(),
+    userId: userId ?? null,
+    kind: identity.kind,
+    provider: identity.provider,
+    providerTenantId: tenantId(identity.providerTenantId),
+    providerSubjectId: identity.providerSubjectId,
+    displayName: identity.displayName ?? null,
+    handle: identity.handle ?? null,
+    email: email ?? null,
+    emailNormalized: emailNormalized ?? null,
+    emailVerified: Boolean(identity.emailVerified && emailNormalized),
+    avatarUrl: null,
+    metadata: identity.metadata ?? null,
+    createdAt: dateFromMs(nowMs),
+    updatedAt: dateFromMs(nowMs)
+  }).onConflictDoUpdate({
+    target: [
+      juniorIdentities.provider,
+      juniorIdentities.providerTenantId,
+      juniorIdentities.providerSubjectId
+    ],
+    set: {
+      kind: sql3`excluded.kind`,
+      userId: sql3`coalesce(${juniorIdentities.userId}, excluded.user_id)`,
+      displayName: sql3`coalesce(${juniorIdentities.displayName}, excluded.display_name)`,
+      handle: sql3`coalesce(${juniorIdentities.handle}, excluded.handle)`,
+      email: sql3`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: sql3`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: sql3`${juniorIdentities.emailVerified} OR excluded.email_verified`,
+      avatarUrl: sql3`coalesce(${juniorIdentities.avatarUrl}, excluded.avatar_url)`,
+      metadata: sql3`coalesce(${juniorIdentities.metadata}, excluded.metadata_json)`,
+      updatedAt: sql3`excluded.updated_at`
+    }
+  }).returning({
+    id: juniorIdentities.id,
+    userId: juniorIdentities.userId
+  });
+  const row = rows[0];
+  if (!row) {
+    throw new Error("Identity upsert returned no row");
+  }
+  return {
+    id: row.id,
+    ...row.userId ? { userId: row.userId } : {}
+  };
+}
+
 // src/chat/conversations/sql/migrations.ts
+import { createHash } from "crypto";
+import { z } from "zod";
 var MIGRATION_LOCK_NAME = "junior_conversation_schema";
 var migrationRecordSchema = z.object({
   id: z.string().min(1),
@@ -306,12 +458,103 @@ UPDATE junior_destinations
     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 migrations = [
   defineMigration("0001_conversation_core", coreMetadataStatements),
   defineMigration(
     "0002_slack_destination_visibility_backfill",
     destinationVisibilityBackfillStatements
-  )
+  ),
+  defineMigration("0003_user_identities", userIdentityStatements)
 ];
 function parseStoredMigrationRecord(value) {
   return migrationRecordSchema.parse(value);
@@ -362,12 +605,9 @@ var CONVERSATION_MUTATION_LOCK_PREFIX = "junior_conversation";
 function now() {
   return Date.now();
 }
-function dateFromMs(ms) {
+function dateFromMs2(ms) {
   return new Date(ms);
 }
-function tenantId(value) {
-  return value ?? "";
-}
 function msFromDate(value) {
   if (value === null || value === void 0) {
     return void 0;
@@ -382,6 +622,9 @@ function requiredMsFromDate(value) {
   }
   return ms;
 }
+function tenantId2(value) {
+  return value ?? "";
+}
 function sourceFromValue(value) {
   if (value === "api" || value === "internal" || value === "local" || value === "plugin" || value === "resource_event" || value === "scheduler" || value === "slack") {
     return value;
@@ -399,7 +642,7 @@ function identityFromRequester(requester) {
     providerSubjectId: requester.slackUserId,
     ...requester.fullName ? { displayName: requester.fullName } : {},
     ...requester.slackUserName ? { handle: requester.slackUserName } : {},
-    ...requester.email ? { email: requester.email } : {},
+    ...requester.email ? { email: requester.email, emailVerified: true } : {},
     metadata: { platform: "slack" }
   };
 }
@@ -481,6 +724,20 @@ function privacyFromRow(row) {
   }
   return row.destinationVisibility === "public" ? "public" : "private";
 }
+function requesterFromIdentityRow(identity, fallback) {
+  if (!identity || identity.provider !== "slack") {
+    return fallback;
+  }
+  return {
+    ...fallback ?? {},
+    ...identity.emailNormalized ? { email: identity.emailNormalized } : identity.email ? { email: identity.email } : {},
+    ...identity.displayName ? { fullName: identity.displayName } : {},
+    platform: "slack",
+    slackUserId: identity.providerSubjectId,
+    ...identity.handle ? { slackUserName: identity.handle } : {},
+    ...identity.providerTenantId || fallback?.teamId ? { teamId: identity.providerTenantId || fallback?.teamId } : {}
+  };
+}
 function conversationFromRow(readRow) {
   const row = readRow.conversation;
   const visibility = privacyFromRow(readRow);
@@ -488,7 +745,10 @@ function conversationFromRow(readRow) {
     throw new Error("Conversation record schema version is invalid");
   }
   const destination = row.destination === void 0 || row.destination === null ? void 0 : parseDestination(row.destination);
-  const requester = parseStoredSlackRequester(row.requester);
+  const requester = requesterFromIdentityRow(
+    readRow.requesterIdentity,
+    parseStoredSlackRequester(row.requester)
+  );
   if (row.destination !== void 0 && row.destination !== null && !destination) {
     throw new Error("Conversation record destination is invalid");
   }
@@ -544,6 +804,26 @@ function assertSameConversationDestination(args) {
     `Conversation destination changed for ${args.conversationId}`
   );
 }
+function mergeRequester(current2, next) {
+  if (!current2) {
+    return next;
+  }
+  if (!next) {
+    return current2;
+  }
+  if (current2.slackUserId && next.slackUserId && current2.slackUserId !== next.slackUserId) {
+    return current2;
+  }
+  return {
+    ...current2,
+    ...current2.email ?? next.email ? { email: current2.email ?? next.email } : {},
+    ...current2.fullName ?? next.fullName ? { fullName: current2.fullName ?? next.fullName } : {},
+    ...current2.platform ?? next.platform ? { platform: current2.platform ?? next.platform } : {},
+    ...current2.slackUserId ?? next.slackUserId ? { slackUserId: current2.slackUserId ?? next.slackUserId } : {},
+    ...current2.slackUserName ?? next.slackUserName ? { slackUserName: current2.slackUserName ?? next.slackUserName } : {},
+    ...current2.teamId ?? next.teamId ? { teamId: current2.teamId ?? next.teamId } : {}
+  };
+}
 var SqlStore = class {
   constructor(executor, migrationExecutor) {
     this.executor = executor;
@@ -601,7 +881,7 @@ var SqlStore = class {
           destination: current2.destination ?? args.destination,
           source: current2.source ?? args.source,
           channelName: current2.channelName ?? args.channelName,
-          requester: current2.requester ?? args.requester,
+          requester: mergeRequester(current2.requester, args.requester),
           title: current2.title ?? args.title,
           lastActivityAtMs: Math.max(current2.lastActivityAtMs, activityAtMs),
           updatedAtMs: nowMs,
@@ -674,10 +954,14 @@ var SqlStore = class {
   async listByActivity(args = {}) {
     const rows = await this.executor.db().select({
       conversation: juniorConversations,
-      destinationVisibility: juniorDestinations.visibility
+      destinationVisibility: juniorDestinations.visibility,
+      requesterIdentity: juniorIdentities
     }).from(juniorConversations).leftJoin(
       juniorDestinations,
-      eq(juniorDestinations.id, juniorConversations.destinationId)
+      eq2(juniorDestinations.id, juniorConversations.destinationId)
+    ).leftJoin(
+      juniorIdentities,
+      eq2(juniorIdentities.id, juniorConversations.requesterIdentityId)
     ).orderBy(
       desc(juniorConversations.lastActivityAt),
       asc(juniorConversations.conversationId)
@@ -692,13 +976,13 @@ var SqlStore = class {
     const rows = await this.executor.db().select({
       visibility: juniorDestinations.visibility
     }).from(juniorDestinations).where(
-      and(
-        eq(juniorDestinations.provider, args.provider),
-        eq(
+      and2(
+        eq2(juniorDestinations.provider, args.provider),
+        eq2(
           juniorDestinations.providerTenantId,
-          tenantId(args.providerTenantId)
+          tenantId2(args.providerTenantId)
         ),
-        eq(
+        eq2(
           juniorDestinations.providerDestinationId,
           args.providerDestinationId
         )
@@ -720,19 +1004,23 @@ var SqlStore = class {
   async readConversationRow(conversationId) {
     const rows = await this.executor.db().select({
       conversation: juniorConversations,
-      destinationVisibility: juniorDestinations.visibility
+      destinationVisibility: juniorDestinations.visibility,
+      requesterIdentity: juniorIdentities
     }).from(juniorConversations).leftJoin(
       juniorDestinations,
-      eq(juniorDestinations.id, juniorConversations.destinationId)
-    ).where(eq(juniorConversations.conversationId, conversationId));
+      eq2(juniorDestinations.id, juniorConversations.destinationId)
+    ).leftJoin(
+      juniorIdentities,
+      eq2(juniorIdentities.id, juniorConversations.requesterIdentityId)
+    ).where(eq2(juniorConversations.conversationId, conversationId));
     return rows[0];
   }
   /** Upsert the conversation row while preserving previously discovered nullable metadata fields. */
   async upsertConversation(args) {
     const { conversation } = args;
-    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 incomingExecutionVersion = sql4`coalesce(excluded.execution_updated_at, excluded.updated_at)`;
+    const currentExecutionVersion = sql4`coalesce(${juniorConversations.executionUpdatedAt}, ${juniorConversations.updatedAt})`;
+    const incomingExecutionIsFresh = sql4`${incomingExecutionVersion} >= ${currentExecutionVersion}`;
     const destinationId = await this.upsertDestination(
       destinationUpsertFromDestination({
         channelName: conversation.channelName,
@@ -742,14 +1030,20 @@ var SqlStore = class {
       }),
       conversation.updatedAtMs
     );
-    const requesterIdentityId = await this.upsertIdentity(
-      identityFromRequester(conversation.requester),
-      conversation.updatedAtMs
+    const requesterIdentityObservation = identityFromRequester(
+      conversation.requester
     );
-    const actorIdentityId = await this.upsertIdentity(
-      actorIdentityForConversation(conversation),
+    const requesterIdentity = requesterIdentityObservation ? await upsertIdentity(
+      this.executor,
+      requesterIdentityObservation,
       conversation.updatedAtMs
-    );
+    ) : void 0;
+    const actorIdentityObservation = actorIdentityForConversation(conversation);
+    const actorIdentity = actorIdentityObservation ? await upsertIdentity(
+      this.executor,
+      actorIdentityObservation,
+      conversation.updatedAtMs
+    ) : void 0;
     await this.executor.db().insert(juniorConversations).values({
       conversationId: conversation.conversationId,
       schemaVersion: 1,
@@ -759,100 +1053,65 @@ var SqlStore = class {
       originRunId: null,
       destinationId: destinationId ?? null,
       destination: conversation.destination ?? null,
-      actorIdentityId: actorIdentityId ?? null,
-      requesterIdentityId: requesterIdentityId ?? null,
+      actorIdentityId: actorIdentity?.id ?? null,
+      requesterIdentityId: requesterIdentity?.id ?? null,
       creatorIdentityId: null,
       credentialSubjectIdentityId: null,
       requester: conversation.requester ?? null,
       channelName: conversation.channelName ?? null,
       title: conversation.title ?? null,
-      createdAt: dateFromMs(conversation.createdAtMs),
-      lastActivityAt: dateFromMs(conversation.lastActivityAtMs),
-      updatedAt: dateFromMs(conversation.updatedAtMs),
-      executionUpdatedAt: conversation.execution.updatedAtMs === void 0 ? null : dateFromMs(conversation.execution.updatedAtMs),
+      createdAt: dateFromMs2(conversation.createdAtMs),
+      lastActivityAt: dateFromMs2(conversation.lastActivityAtMs),
+      updatedAt: dateFromMs2(conversation.updatedAtMs),
+      executionUpdatedAt: conversation.execution.updatedAtMs === void 0 ? null : dateFromMs2(conversation.execution.updatedAtMs),
       executionStatus: conversation.execution.status,
       runId: conversation.execution.runId ?? null,
-      lastCheckpointAt: conversation.execution.lastCheckpointAtMs === void 0 ? null : dateFromMs(conversation.execution.lastCheckpointAtMs),
-      lastEnqueuedAt: conversation.execution.lastEnqueuedAtMs === void 0 ? null : dateFromMs(conversation.execution.lastEnqueuedAtMs)
+      lastCheckpointAt: conversation.execution.lastCheckpointAtMs === void 0 ? null : dateFromMs2(conversation.execution.lastCheckpointAtMs),
+      lastEnqueuedAt: conversation.execution.lastEnqueuedAtMs === void 0 ? null : dateFromMs2(conversation.execution.lastEnqueuedAtMs)
     }).onConflictDoUpdate({
       target: juniorConversations.conversationId,
       set: {
-        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})`,
-        destination: sql2`coalesce(excluded.destination_json, ${juniorConversations.destination})`,
-        actorIdentityId: sql2`coalesce(excluded.actor_identity_id, ${juniorConversations.actorIdentityId})`,
-        requesterIdentityId: sql2`coalesce(excluded.requester_identity_id, ${juniorConversations.requesterIdentityId})`,
-        creatorIdentityId: sql2`coalesce(excluded.creator_identity_id, ${juniorConversations.creatorIdentityId})`,
-        credentialSubjectIdentityId: sql2`coalesce(excluded.credential_subject_identity_id, ${juniorConversations.credentialSubjectIdentityId})`,
-        requester: sql2`coalesce(excluded.requester_json, ${juniorConversations.requester})`,
-        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`
+        source: sql4`coalesce(excluded.source, ${juniorConversations.source})`,
+        originType: sql4`coalesce(excluded.origin_type, ${juniorConversations.originType})`,
+        originId: sql4`coalesce(excluded.origin_id, ${juniorConversations.originId})`,
+        originRunId: sql4`coalesce(excluded.origin_run_id, ${juniorConversations.originRunId})`,
+        destinationId: sql4`coalesce(excluded.destination_id, ${juniorConversations.destinationId})`,
+        destination: sql4`coalesce(excluded.destination_json, ${juniorConversations.destination})`,
+        actorIdentityId: sql4`coalesce(excluded.actor_identity_id, ${juniorConversations.actorIdentityId})`,
+        requesterIdentityId: sql4`coalesce(excluded.requester_identity_id, ${juniorConversations.requesterIdentityId})`,
+        creatorIdentityId: sql4`coalesce(excluded.creator_identity_id, ${juniorConversations.creatorIdentityId})`,
+        credentialSubjectIdentityId: sql4`coalesce(excluded.credential_subject_identity_id, ${juniorConversations.credentialSubjectIdentityId})`,
+        requester: sql4`coalesce(excluded.requester_json, ${juniorConversations.requester})`,
+        channelName: sql4`coalesce(excluded.channel_name, ${juniorConversations.channelName})`,
+        title: sql4`coalesce(excluded.title, ${juniorConversations.title})`,
+        createdAt: sql4`least(${juniorConversations.createdAt}, excluded.created_at)`,
+        lastActivityAt: sql4`greatest(${juniorConversations.lastActivityAt}, excluded.last_activity_at)`,
+        updatedAt: sql4`greatest(${juniorConversations.updatedAt}, excluded.updated_at)`,
+        executionUpdatedAt: sql4`case when ${incomingExecutionIsFresh} then excluded.execution_updated_at else ${juniorConversations.executionUpdatedAt} end`,
+        executionStatus: sql4`case when ${incomingExecutionIsFresh} then excluded.execution_status else ${juniorConversations.executionStatus} end`,
+        runId: sql4`case when ${incomingExecutionIsFresh} then excluded.run_id else ${juniorConversations.runId} end`,
+        lastCheckpointAt: sql4`case when ${incomingExecutionIsFresh} then coalesce(excluded.last_checkpoint_at, ${juniorConversations.lastCheckpointAt}) else ${juniorConversations.lastCheckpointAt} end`,
+        lastEnqueuedAt: sql4`case when ${incomingExecutionIsFresh} then coalesce(excluded.last_enqueued_at, ${juniorConversations.lastEnqueuedAt}) else ${juniorConversations.lastEnqueuedAt} end`
       }
     });
   }
-  async upsertIdentity(identity, nowMs) {
-    if (!identity) {
-      return void 0;
-    }
-    const rows = await this.executor.db().insert(juniorIdentities).values({
-      id: randomUUID(),
-      kind: identity.kind,
-      provider: identity.provider,
-      providerTenantId: tenantId(identity.providerTenantId),
-      providerSubjectId: identity.providerSubjectId,
-      displayName: identity.displayName ?? null,
-      handle: identity.handle ?? null,
-      email: identity.email ?? null,
-      avatarUrl: null,
-      metadata: identity.metadata ?? null,
-      createdAt: dateFromMs(nowMs),
-      updatedAt: dateFromMs(nowMs)
-    }).onConflictDoUpdate({
-      target: [
-        juniorIdentities.provider,
-        juniorIdentities.providerTenantId,
-        juniorIdentities.providerSubjectId
-      ],
-      set: {
-        kind: sql2`excluded.kind`,
-        displayName: sql2`coalesce(excluded.display_name, ${juniorIdentities.displayName})`,
-        handle: sql2`coalesce(excluded.handle, ${juniorIdentities.handle})`,
-        email: sql2`coalesce(excluded.email, ${juniorIdentities.email})`,
-        avatarUrl: sql2`coalesce(excluded.avatar_url, ${juniorIdentities.avatarUrl})`,
-        metadata: sql2`coalesce(excluded.metadata_json, ${juniorIdentities.metadata})`,
-        updatedAt: sql2`excluded.updated_at`
-      }
-    }).returning({ id: juniorIdentities.id });
-    return rows[0]?.id;
-  }
   async upsertDestination(destination, nowMs) {
     if (!destination) {
       return void 0;
     }
-    const visibilityUpdate = destination.refreshVisibility ? sql2`excluded.visibility` : juniorDestinations.visibility;
+    const visibilityUpdate = destination.refreshVisibility ? sql4`excluded.visibility` : juniorDestinations.visibility;
     const rows = await this.executor.db().insert(juniorDestinations).values({
-      id: randomUUID(),
+      id: randomUUID2(),
       provider: destination.provider,
-      providerTenantId: tenantId(destination.providerTenantId),
+      providerTenantId: tenantId2(destination.providerTenantId),
       providerDestinationId: destination.providerDestinationId,
       kind: destination.kind,
       parentDestinationId: null,
       displayName: destination.displayName ?? null,
       visibility: destination.visibility,
       metadata: destination.metadata ?? null,
-      createdAt: dateFromMs(nowMs),
-      updatedAt: dateFromMs(nowMs)
+      createdAt: dateFromMs2(nowMs),
+      updatedAt: dateFromMs2(nowMs)
     }).onConflictDoUpdate({
       target: [
         juniorDestinations.provider,
@@ -860,14 +1119,14 @@ var SqlStore = class {
         juniorDestinations.providerDestinationId
       ],
       set: {
-        kind: sql2`excluded.kind`,
-        displayName: sql2`coalesce(excluded.display_name, ${juniorDestinations.displayName})`,
+        kind: sql4`excluded.kind`,
+        displayName: sql4`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: sql2`coalesce(excluded.metadata_json, ${juniorDestinations.metadata})`,
-        updatedAt: sql2`excluded.updated_at`
+        metadata: sql4`coalesce(excluded.metadata_json, ${juniorDestinations.metadata})`,
+        updatedAt: sql4`excluded.updated_at`
       }
     }).returning({ id: juniorDestinations.id });
     return rows[0]?.id;
@@ -883,13 +1142,6 @@ import {
   Pool
 } from "@neondatabase/serverless";
 import { drizzle } from "drizzle-orm/neon-serverless";
-
-// src/chat/sql/schema.ts
-var juniorSqlSchema = {
-  ...schema
-};
-
-// src/chat/sql/neon.ts
 var NeonExecutor = class {
   constructor(pool) {
     this.pool = pool;
@@ -1105,20 +1357,20 @@ function createDb(args) {
   });
 }
 function getSqlExecutor() {
-  const { sql: sql3 } = getChatConfig();
-  if (current?.databaseUrl !== sql3.databaseUrl || current.driver !== sql3.driver) {
+  const { sql: sql5 } = getChatConfig();
+  if (current?.databaseUrl !== sql5.databaseUrl || current.driver !== sql5.driver) {
     if (current) {
       const previous = current;
       current = void 0;
       void previous.db.close().catch(() => void 0);
     }
     const db = createDb({
-      databaseUrl: sql3.databaseUrl,
-      driver: sql3.driver
+      databaseUrl: sql5.databaseUrl,
+      driver: sql5.driver
     });
     current = {
-      databaseUrl: sql3.databaseUrl,
-      driver: sql3.driver,
+      databaseUrl: sql5.databaseUrl,
+      driver: sql5.driver,
       db,
       store: createSqlStore(db)
     };
@@ -1139,6 +1391,10 @@ async function closeDb() {
 }
 
 export {
+  juniorDestinations,
+  juniorUsers,
+  juniorIdentities,
+  juniorConversations,
   createSqlStore,
   createJuniorSqlExecutor,
   getDb,