@sentry/junior 0.153.0 → 0.155.0

package/dist/{chunk-XAYXN4EG.js → chunk-JJX77MB7.js}

@@ -2,29 +2,31 @@ import {
   createJuniorSqlExecutor,
   juniorConversationBindings,
   juniorConversationEvents,
+  juniorConversationParticipants,
   juniorConversations,
   juniorIdentities,
   juniorUsers
-} from "./chunk-ET54Q4TD.js";
+} from "./chunk-773XC7P4.js";
 import {
   TURN_REASONING_LEVELS,
   getChatConfig,
   modelProfileSchema
-} from "./chunk-PGJBNO3I.js";
+} from "./chunk-XFZLQANQ.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
 import {
+  parseActorUserId,
   parseSlackChannelReferenceId,
   parseSlackTeamId
-} from "./chunk-F3B2YJ76.js";
+} from "./chunk-V7YE4WCP.js";
 import {
   normalizeIdentityEmail
-} from "./chunk-HMU2QP5M.js";
+} from "./chunk-7NYEB2TM.js";
 
 // src/chat/conversations/sql/store.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { and as and3, asc, desc, eq as eq3, isNull, sql as sql2 } from "drizzle-orm";
+import { and as and4, asc, desc, eq as eq4, isNull, sql as sql3 } from "drizzle-orm";
 
 // src/chat/destination.ts
 import {
@@ -206,6 +208,42 @@ async function deleteProviderIdentityForSlackUser(executor, slackTeamId, slackUs
   );
 }
 
+// src/chat/conversations/sql/participants.ts
+import { and as and2, eq as eq2, inArray, sql as sql2 } from "drizzle-orm";
+async function resolveRootConversationId(executor, conversationId) {
+  const [row] = await executor.db().select({
+    rootConversationId: juniorConversations.rootConversationId
+  }).from(juniorConversations).where(eq2(juniorConversations.conversationId, conversationId)).limit(1);
+  return row?.rootConversationId ?? conversationId;
+}
+async function recordConversationParticipant(executor, args) {
+  const [identity] = await executor.db().select({
+    kind: juniorIdentities.kind,
+    userId: juniorIdentities.userId
+  }).from(juniorIdentities).where(eq2(juniorIdentities.id, args.actorIdentityId)).limit(1);
+  if (!identity?.userId || identity.kind !== "user") {
+    return;
+  }
+  const rootConversationId = await resolveRootConversationId(
+    executor,
+    args.conversationId
+  );
+  const at = new Date(args.atMs);
+  await executor.db().insert(juniorConversationParticipants).values({
+    userId: identity.userId,
+    rootConversationId,
+    lastMessageAt: at
+  }).onConflictDoUpdate({
+    target: [
+      juniorConversationParticipants.userId,
+      juniorConversationParticipants.rootConversationId
+    ],
+    set: {
+      lastMessageAt: sql2`greatest(${juniorConversationParticipants.lastMessageAt}, excluded.last_message_at)`
+    }
+  });
+}
+
 // src/chat/source.ts
 import { sourceSchema } from "@sentry/junior-plugin-api";
 function normalizeSessionSource(value) {
@@ -241,17 +279,17 @@ function parseSessionSource(value) {
 }
 
 // src/chat/conversations/sql/bindings.ts
-import { and as and2, eq as eq2 } from "drizzle-orm";
+import { and as and3, eq as eq3 } from "drizzle-orm";
 async function getConversationIdByProviderConversation(executor, args) {
   const rows = await executor.db().select({ conversationId: juniorConversationBindings.conversationId }).from(juniorConversationBindings).where(
-    and2(
-      eq2(juniorConversationBindings.provider, args.provider),
-      eq2(juniorConversationBindings.providerTenantId, args.providerTenantId),
-      eq2(
+    and3(
+      eq3(juniorConversationBindings.provider, args.provider),
+      eq3(juniorConversationBindings.providerTenantId, args.providerTenantId),
+      eq3(
         juniorConversationBindings.providerDestinationId,
         args.providerDestinationId
       ),
-      eq2(
+      eq3(
         juniorConversationBindings.providerConversationId,
         args.providerConversationId
       )
@@ -768,7 +806,7 @@ var SqlStore = class {
           metricRunId: args.execution.runId ?? null,
           executionDurationMs: args.metrics.durationMs,
           executionUsage: args.metrics.usage ?? (sameRun ? row?.executionUsage ?? null : null)
-        }).where(eq3(juniorConversations.conversationId, args.conversationId));
+        }).where(eq4(juniorConversations.conversationId, args.conversationId));
       }
     });
   }
@@ -780,11 +818,11 @@ var SqlStore = class {
       actorUserDisplayName: juniorUsers.displayName
     }).from(juniorConversations).leftJoin(
       juniorDestinations,
-      eq3(juniorDestinations.id, juniorConversations.destinationId)
+      eq4(juniorDestinations.id, juniorConversations.destinationId)
     ).leftJoin(
       juniorIdentities,
-      eq3(juniorIdentities.id, juniorConversations.actorIdentityId)
-    ).leftJoin(juniorUsers, eq3(juniorUsers.id, juniorIdentities.userId)).where(isNull(juniorConversations.parentConversationId)).orderBy(
+      eq4(juniorIdentities.id, juniorConversations.actorIdentityId)
+    ).leftJoin(juniorUsers, eq4(juniorUsers.id, juniorIdentities.userId)).where(isNull(juniorConversations.parentConversationId)).orderBy(
       desc(juniorConversations.lastActivityAt),
       asc(juniorConversations.conversationId)
     ).limit(Math.max(0, args.limit ?? 1e4)).offset(Math.max(0, args.offset ?? 0));
@@ -798,13 +836,13 @@ var SqlStore = class {
     const rows = await this.executor.db().select({
       visibility: juniorDestinations.visibility
     }).from(juniorDestinations).where(
-      and3(
-        eq3(juniorDestinations.provider, args.provider),
-        eq3(
+      and4(
+        eq4(juniorDestinations.provider, args.provider),
+        eq4(
           juniorDestinations.providerTenantId,
           tenantId2(args.providerTenantId)
         ),
-        eq3(
+        eq4(
           juniorDestinations.providerDestinationId,
           args.providerDestinationId
         )
@@ -835,19 +873,19 @@ var SqlStore = class {
       actorUserDisplayName: juniorUsers.displayName
     }).from(juniorConversations).leftJoin(
       juniorDestinations,
-      eq3(juniorDestinations.id, juniorConversations.destinationId)
+      eq4(juniorDestinations.id, juniorConversations.destinationId)
     ).leftJoin(
       juniorIdentities,
-      eq3(juniorIdentities.id, juniorConversations.actorIdentityId)
-    ).leftJoin(juniorUsers, eq3(juniorUsers.id, juniorIdentities.userId)).where(eq3(juniorConversations.conversationId, conversationId));
+      eq4(juniorIdentities.id, juniorConversations.actorIdentityId)
+    ).leftJoin(juniorUsers, eq4(juniorUsers.id, juniorIdentities.userId)).where(eq4(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 = sql3`coalesce(excluded.execution_updated_at, excluded.updated_at)`;
+    const currentExecutionVersion = sql3`coalesce(${juniorConversations.executionUpdatedAt}, ${juniorConversations.updatedAt})`;
+    const incomingExecutionIsFresh = sql3`${incomingExecutionVersion} >= ${currentExecutionVersion}`;
     const destinationId = await this.upsertDestination(
       destinationUpsertFromDestination({
         channelName: conversation.channelName,
@@ -863,7 +901,7 @@ var SqlStore = class {
       actorIdentityObservation,
       conversation.updatedAtMs
     ) : void 0;
-    const rootConversationId = conversation.lineage ? sql2`(
+    const rootConversationId = conversation.lineage ? sql3`(
           select parent.root_conversation_id
           from junior_conversations parent
           where parent.conversation_id = ${conversation.lineage.parentConversationId}
@@ -898,39 +936,49 @@ var SqlStore = class {
       target: juniorConversations.conversationId,
       set: {
         // Origin source is set-once so dashboard continues cannot rewrite a Slack root.
-        source: sql2`coalesce(${juniorConversations.source}, excluded.source)`,
-        sessionSource: sql2`coalesce(${juniorConversations.sessionSource}, excluded.source_json)`,
-        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)`
+        source: sql3`coalesce(${juniorConversations.source}, excluded.source)`,
+        sessionSource: sql3`coalesce(${juniorConversations.sessionSource}, excluded.source_json)`,
+        originType: sql3`coalesce(excluded.origin_type, ${juniorConversations.originType})`,
+        originId: sql3`coalesce(excluded.origin_id, ${juniorConversations.originId})`,
+        originRunId: sql3`coalesce(excluded.origin_run_id, ${juniorConversations.originRunId})`,
+        destinationId: sql3`coalesce(excluded.destination_id, ${juniorConversations.destinationId})`,
+        actorIdentityId: sql3`coalesce(excluded.actor_identity_id, ${juniorConversations.actorIdentityId})`,
+        creatorIdentityId: sql3`coalesce(excluded.creator_identity_id, ${juniorConversations.creatorIdentityId})`,
+        credentialSubjectIdentityId: sql3`coalesce(excluded.credential_subject_identity_id, ${juniorConversations.credentialSubjectIdentityId})`,
+        channelName: sql3`coalesce(excluded.channel_name, ${juniorConversations.channelName})`,
+        title: sql3`coalesce(excluded.title, ${juniorConversations.title})`,
+        createdAt: sql3`least(${juniorConversations.createdAt}, excluded.created_at)`,
+        lastActivityAt: sql3`greatest(${juniorConversations.lastActivityAt}, excluded.last_activity_at)`,
+        updatedAt: sql3`greatest(${juniorConversations.updatedAt}, excluded.updated_at)`,
+        executionUpdatedAt: sql3`case when ${incomingExecutionIsFresh} then excluded.execution_updated_at else ${juniorConversations.executionUpdatedAt} end`,
+        executionStatus: sql3`case when ${incomingExecutionIsFresh} then excluded.execution_status else ${juniorConversations.executionStatus} end`,
+        runId: sql3`case when ${incomingExecutionIsFresh} then excluded.run_id else ${juniorConversations.runId} end`,
+        lastCheckpointAt: sql3`case when ${incomingExecutionIsFresh} then coalesce(excluded.last_checkpoint_at, ${juniorConversations.lastCheckpointAt}) else ${juniorConversations.lastCheckpointAt} end`,
+        lastEnqueuedAt: sql3`case when ${incomingExecutionIsFresh} then coalesce(excluded.last_enqueued_at, ${juniorConversations.lastEnqueuedAt}) else ${juniorConversations.lastEnqueuedAt} end`,
+        rootConversationId: sql3`coalesce(${juniorConversations.rootConversationId}, excluded.root_conversation_id)`
       }
     }).returning({
+      actorIdentityId: juniorConversations.actorIdentityId,
+      parentConversationId: juniorConversations.parentConversationId,
       rootConversationId: juniorConversations.rootConversationId
     });
-    if (!rows[0]?.rootConversationId) {
+    const row = rows[0];
+    if (!row?.rootConversationId) {
       throw new Error("Conversation parent is missing its persisted root");
     }
+    if (row.actorIdentityId && row.parentConversationId === null) {
+      await recordConversationParticipant(this.executor, {
+        actorIdentityId: row.actorIdentityId,
+        conversationId: conversation.conversationId,
+        atMs: conversation.lastActivityAtMs
+      });
+    }
   }
   async upsertDestination(destination, nowMs) {
     if (!destination) {
       return void 0;
     }
-    const visibilityUpdate = destination.refreshVisibility ? sql2`excluded.visibility` : juniorDestinations.visibility;
+    const visibilityUpdate = destination.refreshVisibility ? sql3`excluded.visibility` : juniorDestinations.visibility;
     const rows = await this.executor.db().insert(juniorDestinations).values({
       id: randomUUID2(),
       provider: destination.provider,
@@ -950,14 +998,14 @@ var SqlStore = class {
         juniorDestinations.providerDestinationId
       ],
       set: {
-        kind: sql2`excluded.kind`,
-        displayName: sql2`coalesce(excluded.display_name, ${juniorDestinations.displayName})`,
+        kind: sql3`excluded.kind`,
+        displayName: sql3`coalesce(excluded.display_name, ${juniorDestinations.displayName})`,
         // Signal-less writes remain unknown and 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: sql3`coalesce(excluded.metadata_json, ${juniorDestinations.metadata})`,
+        updatedAt: sql3`excluded.updated_at`
       }
     }).returning({ id: juniorDestinations.id });
     return rows[0]?.id;
@@ -969,17 +1017,17 @@ function createSqlStore(executor) {
 
 // src/chat/conversations/sql/history.ts
 import {
-  and as and4,
+  and as and6,
   asc as asc2,
   desc as desc2,
-  eq as eq4,
+  eq as eq6,
   gt,
   gte,
-  inArray,
+  inArray as inArray2,
   isNotNull,
   lt,
   lte,
-  sql as sql4
+  sql as sql6
 } from "drizzle-orm";
 
 // src/chat/conversations/history.ts
@@ -1344,7 +1392,7 @@ var newConversationEventSchema = z3.object({
 }).strict();
 
 // src/chat/conversations/sql/conversation-row.ts
-import { sql as sql3 } from "drizzle-orm";
+import { sql as sql4 } from "drizzle-orm";
 async function ensureConversationRow(executor, conversationId, atMs, options = {}) {
   const at = new Date(atMs);
   const insert = executor.db().insert(juniorConversations).values({
@@ -1363,13 +1411,169 @@ async function ensureConversationRow(executor, conversationId, atMs, options = {
   await insert.onConflictDoUpdate({
     target: juniorConversations.conversationId,
     set: {
-      lastActivityAt: sql3`greatest(${juniorConversations.lastActivityAt}, excluded.last_activity_at)`,
-      updatedAt: sql3`greatest(${juniorConversations.updatedAt}, excluded.updated_at)`,
+      lastActivityAt: sql4`greatest(${juniorConversations.lastActivityAt}, excluded.last_activity_at)`,
+      updatedAt: sql4`greatest(${juniorConversations.updatedAt}, excluded.updated_at)`,
       transcriptPurgedAt: null
     }
   });
 }
 
+// src/chat/conversations/sql/event-actor.ts
+import { and as and5, eq as eq5, or, sql as sql5 } from "drizzle-orm";
+var SLACK_USER_ID_PATTERN = /^[UW][A-Z0-9]{5,}$/;
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readAuthor(meta) {
+  if (!isRecord(meta) || !isRecord(meta.author)) {
+    return {};
+  }
+  const author = meta.author;
+  return {
+    ...typeof author.email === "string" ? { email: author.email } : {},
+    ...typeof author.fullName === "string" ? { fullName: author.fullName } : {},
+    ...typeof author.isBot === "boolean" ? { isBot: author.isBot } : {},
+    ...typeof author.userId === "string" ? { userId: author.userId } : {},
+    ...typeof author.userName === "string" ? { userName: author.userName } : {}
+  };
+}
+async function loadConversationSlackTenantId(executor, conversationId) {
+  const [row] = await executor.db().select({
+    providerTenantId: juniorDestinations.providerTenantId,
+    sessionSource: juniorConversations.sessionSource
+  }).from(juniorConversations).leftJoin(
+    juniorDestinations,
+    eq5(juniorDestinations.id, juniorConversations.destinationId)
+  ).where(eq5(juniorConversations.conversationId, conversationId)).limit(1);
+  const destinationTenant = row?.providerTenantId?.trim();
+  if (destinationTenant) {
+    return destinationTenant;
+  }
+  const sessionSource = row?.sessionSource;
+  if (isRecord(sessionSource) && sessionSource.platform === "slack" && typeof sessionSource.teamId === "string" && sessionSource.teamId.trim()) {
+    return sessionSource.teamId.trim();
+  }
+  return void 0;
+}
+async function findIdentityIdByProviderSubject(executor, args) {
+  const rows = await executor.db().select({ id: juniorIdentities.id }).from(juniorIdentities).where(
+    and5(
+      eq5(juniorIdentities.provider, args.provider),
+      eq5(juniorIdentities.providerSubjectId, args.providerSubjectId),
+      args.providerTenantId === void 0 ? void 0 : eq5(juniorIdentities.providerTenantId, args.providerTenantId)
+    )
+  ).limit(1);
+  return rows[0]?.id;
+}
+async function findJuniorIdentityIdByEmail(executor, email) {
+  const normalized = email.trim().toLowerCase();
+  if (!normalized) return void 0;
+  const rows = await executor.db().select({ id: juniorIdentities.id }).from(juniorIdentities).where(
+    and5(
+      eq5(juniorIdentities.provider, "junior"),
+      eq5(juniorIdentities.kind, "user"),
+      or(
+        eq5(juniorIdentities.providerSubjectId, normalized),
+        and5(
+          eq5(juniorIdentities.emailNormalized, normalized),
+          eq5(juniorIdentities.emailVerified, true)
+        )
+      )
+    )
+  ).limit(1);
+  return rows[0]?.id;
+}
+async function findJuniorIdentityIdByDashboardAuthorId(executor, dashboardAuthorId) {
+  if (!dashboardAuthorId.startsWith("dashboard:")) {
+    return void 0;
+  }
+  const rows = await executor.db().select({ id: juniorIdentities.id }).from(juniorIdentities).where(
+    and5(
+      eq5(juniorIdentities.provider, "junior"),
+      eq5(juniorIdentities.kind, "user"),
+      eq5(juniorIdentities.emailVerified, true),
+      sql5`${juniorIdentities.emailNormalized} is not null`,
+      // Match webActorFromEmail(): dashboard:${sha256(email).slice(0,24)}
+      sql5`concat(
+          'dashboard:',
+          left(encode(digest(${juniorIdentities.emailNormalized}, 'sha256'), 'hex'), 24)
+        ) = ${dashboardAuthorId}`
+    )
+  ).limit(1);
+  return rows[0]?.id;
+}
+async function resolveEventActorIdentityId(executor, args) {
+  const data = args.data;
+  if (data.type !== "message" && data.type !== "message_updated") {
+    return void 0;
+  }
+  if (typeof data.authorIdentityId === "string" && data.authorIdentityId) {
+    return data.authorIdentityId;
+  }
+  if (data.role !== "user") {
+    return void 0;
+  }
+  const author = readAuthor(data.meta);
+  if (author.isBot === true) {
+    return void 0;
+  }
+  const userId = parseActorUserId(author.userId);
+  if (!userId) {
+    return void 0;
+  }
+  if (SLACK_USER_ID_PATTERN.test(userId)) {
+    const tenantId3 = await loadConversationSlackTenantId(
+      executor,
+      args.conversationId
+    );
+    const observation = {
+      kind: "user",
+      provider: "slack",
+      providerSubjectId: userId,
+      ...tenantId3 ? { providerTenantId: tenantId3 } : {},
+      ...author.fullName ? { displayName: author.fullName } : {},
+      ...author.userName ? { handle: author.userName } : {},
+      ...author.email ? { email: author.email, emailVerified: true } : {}
+    };
+    if (tenantId3) {
+      const stored = await upsertIdentity(executor, observation, args.nowMs);
+      return stored.id;
+    }
+    return await findIdentityIdByProviderSubject(executor, {
+      provider: "slack",
+      providerSubjectId: userId
+    }) ?? void 0;
+  }
+  const email = typeof author.email === "string" && author.email.includes("@") ? author.email.trim().toLowerCase() : userId.includes("@") ? userId.trim().toLowerCase() : void 0;
+  if (email) {
+    const stored = await upsertIdentity(
+      executor,
+      {
+        kind: "user",
+        provider: "junior",
+        providerSubjectId: email,
+        email,
+        emailVerified: true,
+        ...author.fullName ? { displayName: author.fullName } : {},
+        metadata: { platform: "web" }
+      },
+      args.nowMs
+    );
+    return stored.id;
+  }
+  if (userId.startsWith("dashboard:")) {
+    return findJuniorIdentityIdByDashboardAuthorId(executor, userId);
+  }
+  return findJuniorIdentityIdByEmail(executor, userId);
+}
+function stripPayloadAuthorIdentityId(data) {
+  if (data.type !== "message" && data.type !== "message_updated" || data.authorIdentityId === void 0) {
+    return data;
+  }
+  const { authorIdentityId: _authorIdentityId, ...rest } = data;
+  return rest;
+}
+
 // src/db/postgres-json.ts
 function sanitizePostgresJson(value) {
   if (typeof value === "string") {
@@ -1395,10 +1599,7 @@ function sanitizePostgresJson(value) {
 
 // src/chat/conversations/sql/event-lock.ts
 async function withConversationEventLock(executor, conversationId, callback) {
-  return executor.withLock(
-    `junior_conversation:event:${conversationId}`,
-    callback
-  );
+  return executor.withLock(`junior_conversation:${conversationId}`, callback);
 }
 
 // src/chat/conversations/sql/history.ts
@@ -1407,8 +1608,9 @@ var messageHistoryEventTypes = [
   "message_updated",
   "message_handled"
 ];
-function insertFromEvent(conversationId, seq, historyVersion, event) {
-  const { type, ...payload } = conversationEventDataSchema.parse(event.data);
+function insertFromEvent(conversationId, seq, historyVersion, event, actorIdentityId) {
+  const stripped = stripPayloadAuthorIdentityId(event.data);
+  const { type, ...payload } = conversationEventDataSchema.parse(stripped);
   return {
     conversationId,
     seq,
@@ -1417,10 +1619,12 @@ function insertFromEvent(conversationId, seq, historyVersion, event) {
     idempotencyKey: event.idempotencyKey ?? null,
     type,
     payload: sanitizePostgresJson(payload),
+    actorIdentityId: actorIdentityId ?? null,
     createdAt: new Date(event.createdAtMs)
   };
 }
 function eventFromRow(row) {
+  const payload = row.actorIdentityId && typeof row.payload === "object" && row.payload !== null && !Array.isArray(row.payload) && (row.type === "message" || row.type === "message_updated") && !("authorIdentityId" in row.payload) ? { ...row.payload, authorIdentityId: row.actorIdentityId } : row.payload;
   return decodeStoredConversationEvent({
     schemaVersion: row.schemaVersion,
     seq: row.seq,
@@ -1428,7 +1632,7 @@ function eventFromRow(row) {
     ...row.idempotencyKey ? { idempotencyKey: row.idempotencyKey } : {},
     createdAtMs: row.createdAt.getTime(),
     type: row.type,
-    payload: row.payload
+    payload
   });
 }
 function messagesSummarizedEventFromRow(row) {
@@ -1456,12 +1660,12 @@ var SqlConversationEventStore = class {
       const existingKeys = parsed.map((event) => event.idempotencyKey).filter((key) => key !== void 0);
       const persistedKeys = existingKeys.length === 0 ? /* @__PURE__ */ new Set() : new Set(
         (await this.executor.db().select({ key: juniorConversationEvents.idempotencyKey }).from(juniorConversationEvents).where(
-          and4(
-            eq4(
+          and6(
+            eq6(
               juniorConversationEvents.conversationId,
               conversationId
             ),
-            inArray(
+            inArray2(
               juniorConversationEvents.idempotencyKey,
               existingKeys
             )
@@ -1489,8 +1693,8 @@ var SqlConversationEventStore = class {
       );
       if (options.activity !== "preserve") {
         await this.executor.db().update(juniorConversations).set({ archivedAt: null }).where(
-          and4(
-            eq4(juniorConversations.conversationId, conversationId),
+          and6(
+            eq6(juniorConversations.conversationId, conversationId),
             isNotNull(juniorConversations.archivedAt)
           )
         );
@@ -1498,9 +1702,33 @@ var SqlConversationEventStore = class {
       const cursor = await this.readCursor(conversationId);
       const historyVersion = cursor.maxHistoryVersion ?? 0;
       let seq = cursor.nextSeq;
-      const rows = pending.map(
-        (event) => insertFromEvent(conversationId, seq++, historyVersion, event)
-      );
+      const rows = [];
+      for (const event of pending) {
+        const actorIdentityId = await resolveEventActorIdentityId(
+          this.executor,
+          {
+            conversationId,
+            data: event.data,
+            nowMs: event.createdAtMs
+          }
+        );
+        rows.push(
+          insertFromEvent(
+            conversationId,
+            seq++,
+            historyVersion,
+            event,
+            actorIdentityId
+          )
+        );
+        if (actorIdentityId) {
+          await recordConversationParticipant(this.executor, {
+            actorIdentityId,
+            conversationId,
+            atMs: event.createdAtMs
+          });
+        }
+      }
       await this.executor.db().insert(juniorConversationEvents).values(rows);
     });
   }
@@ -1509,8 +1737,8 @@ var SqlConversationEventStore = class {
     await withConversationEventLock(this.executor, conversationId, async () => {
       await ensureConversationRow(this.executor, conversationId, Date.now());
       await this.executor.db().update(juniorConversations).set({ archivedAt: null }).where(
-        and4(
-          eq4(juniorConversations.conversationId, conversationId),
+        and6(
+          eq6(juniorConversations.conversationId, conversationId),
           isNotNull(juniorConversations.archivedAt)
         )
       );
@@ -1532,34 +1760,34 @@ var SqlConversationEventStore = class {
       return [];
     }
     const rows = await this.executor.db().select().from(juniorConversationEvents).where(
-      and4(
-        eq4(juniorConversationEvents.conversationId, conversationId),
-        eq4(juniorConversationEvents.historyVersion, cursor.maxHistoryVersion)
+      and6(
+        eq6(juniorConversationEvents.conversationId, conversationId),
+        eq6(juniorConversationEvents.historyVersion, cursor.maxHistoryVersion)
       )
     ).orderBy(asc2(juniorConversationEvents.seq));
     return rows.map(eventFromRow);
   }
   async loadByIdempotencyKey(conversationId, idempotencyKey) {
     const [row] = await this.executor.db().select().from(juniorConversationEvents).where(
-      and4(
-        eq4(juniorConversationEvents.conversationId, conversationId),
-        eq4(juniorConversationEvents.idempotencyKey, idempotencyKey)
+      and6(
+        eq6(juniorConversationEvents.conversationId, conversationId),
+        eq6(juniorConversationEvents.idempotencyKey, idempotencyKey)
       )
     ).limit(1);
     return row ? eventFromRow(row) : void 0;
   }
   async loadHistoryContaining(conversationId, seq, throughSeq) {
     const [boundary] = await this.executor.db().select({ historyVersion: juniorConversationEvents.historyVersion }).from(juniorConversationEvents).where(
-      and4(
-        eq4(juniorConversationEvents.conversationId, conversationId),
-        eq4(juniorConversationEvents.seq, seq)
+      and6(
+        eq6(juniorConversationEvents.conversationId, conversationId),
+        eq6(juniorConversationEvents.seq, seq)
       )
     ).limit(1);
     if (!boundary) return void 0;
     const rows = await this.executor.db().select().from(juniorConversationEvents).where(
-      and4(
-        eq4(juniorConversationEvents.conversationId, conversationId),
-        eq4(juniorConversationEvents.historyVersion, boundary.historyVersion),
+      and6(
+        eq6(juniorConversationEvents.conversationId, conversationId),
+        eq6(juniorConversationEvents.historyVersion, boundary.historyVersion),
         throughSeq === void 0 ? void 0 : lte(juniorConversationEvents.seq, throughSeq)
       )
     ).orderBy(asc2(juniorConversationEvents.seq));
@@ -1567,45 +1795,45 @@ var SqlConversationEventStore = class {
   }
   async loadLatestStructuredEvent(conversationId, namespace, name) {
     const [row] = await this.executor.db().select().from(juniorConversationEvents).where(
-      and4(
-        eq4(juniorConversationEvents.conversationId, conversationId),
-        eq4(juniorConversationEvents.type, "structured_event"),
-        sql4`${juniorConversationEvents.payload}->>'namespace' = ${namespace}`,
-        sql4`${juniorConversationEvents.payload}->>'name' = ${name}`
+      and6(
+        eq6(juniorConversationEvents.conversationId, conversationId),
+        eq6(juniorConversationEvents.type, "structured_event"),
+        sql6`${juniorConversationEvents.payload}->>'namespace' = ${namespace}`,
+        sql6`${juniorConversationEvents.payload}->>'name' = ${name}`
       )
     ).orderBy(desc2(juniorConversationEvents.seq)).limit(1);
     return row ? eventFromRow(row) : void 0;
   }
   async loadLatestInstruction(conversationId) {
     const [row] = await this.executor.db().select().from(juniorConversationEvents).where(
-      and4(
-        eq4(juniorConversationEvents.conversationId, conversationId),
-        eq4(juniorConversationEvents.type, "user_message"),
-        sql4`${juniorConversationEvents.payload}->'provenance'->>'authority' = 'instruction'`
+      and6(
+        eq6(juniorConversationEvents.conversationId, conversationId),
+        eq6(juniorConversationEvents.type, "user_message"),
+        sql6`${juniorConversationEvents.payload}->'provenance'->>'authority' = 'instruction'`
       )
     ).orderBy(desc2(juniorConversationEvents.seq)).limit(1);
     return row ? eventFromRow(row) : void 0;
   }
   async loadMessageHistory(conversationId) {
     const [compactionRow] = await this.executor.db().select().from(juniorConversationEvents).where(
-      and4(
-        eq4(juniorConversationEvents.conversationId, conversationId),
-        eq4(juniorConversationEvents.type, "messages_summarized")
+      and6(
+        eq6(juniorConversationEvents.conversationId, conversationId),
+        eq6(juniorConversationEvents.type, "messages_summarized")
       )
     ).orderBy(desc2(juniorConversationEvents.seq)).limit(1);
     const compaction = compactionRow ? messagesSummarizedEventFromRow(compactionRow) : void 0;
     const historyFromSeq = compaction?.data.historyFromSeq ?? 0;
     const rows = await this.executor.db().select().from(juniorConversationEvents).where(
-      and4(
-        eq4(juniorConversationEvents.conversationId, conversationId),
-        inArray(juniorConversationEvents.type, messageHistoryEventTypes),
+      and6(
+        eq6(juniorConversationEvents.conversationId, conversationId),
+        inArray2(juniorConversationEvents.type, messageHistoryEventTypes),
         gte(juniorConversationEvents.seq, historyFromSeq)
       )
     ).orderBy(asc2(juniorConversationEvents.seq));
     return { events: rows.map(eventFromRow), compaction, historyFromSeq };
   }
   async loadHistory(conversationId) {
-    const rows = await this.executor.db().select().from(juniorConversationEvents).where(eq4(juniorConversationEvents.conversationId, conversationId)).orderBy(asc2(juniorConversationEvents.seq));
+    const rows = await this.executor.db().select().from(juniorConversationEvents).where(eq6(juniorConversationEvents.conversationId, conversationId)).orderBy(asc2(juniorConversationEvents.seq));
     return rows.map(eventFromRow);
   }
   async query(conversationId, query) {
@@ -1615,9 +1843,9 @@ var SqlConversationEventStore = class {
     if (query.afterSeq !== void 0 && query.beforeSeq !== void 0 && query.afterSeq >= query.beforeSeq) {
       return { events: [], hasOlder: false, hasNewer: false };
     }
-    const typeFilter = query.types && query.types.length > 0 ? inArray(juniorConversationEvents.type, [...query.types]) : void 0;
-    const bounds = and4(
-      eq4(juniorConversationEvents.conversationId, conversationId),
+    const typeFilter = query.types && query.types.length > 0 ? inArray2(juniorConversationEvents.type, [...query.types]) : void 0;
+    const bounds = and6(
+      eq6(juniorConversationEvents.conversationId, conversationId),
       query.afterSeq === void 0 ? void 0 : gt(juniorConversationEvents.seq, query.afterSeq),
       query.beforeSeq === void 0 ? void 0 : lt(juniorConversationEvents.seq, query.beforeSeq),
       typeFilter
@@ -1654,8 +1882,8 @@ var SqlConversationEventStore = class {
       return false;
     }
     const [row] = await this.executor.db().select({ seq: juniorConversationEvents.seq }).from(juniorConversationEvents).where(
-      and4(
-        eq4(juniorConversationEvents.conversationId, args.conversationId),
+      and6(
+        eq6(juniorConversationEvents.conversationId, args.conversationId),
         args.afterSeq === void 0 ? void 0 : gt(juniorConversationEvents.seq, args.afterSeq),
         args.beforeSeq === void 0 ? void 0 : lt(juniorConversationEvents.seq, args.beforeSeq),
         args.typeFilter
@@ -1666,9 +1894,9 @@ var SqlConversationEventStore = class {
   /** Read the next sequence and active model-history version. */
   async readCursor(conversationId) {
     const rows = await this.executor.db().select({
-      maxSeq: sql4`max(${juniorConversationEvents.seq})`,
-      maxHistoryVersion: sql4`max(${juniorConversationEvents.historyVersion})`
-    }).from(juniorConversationEvents).where(eq4(juniorConversationEvents.conversationId, conversationId));
+      maxSeq: sql6`max(${juniorConversationEvents.seq})`,
+      maxHistoryVersion: sql6`max(${juniorConversationEvents.historyVersion})`
+    }).from(juniorConversationEvents).where(eq6(juniorConversationEvents.conversationId, conversationId));
     const maxSeq = rows[0]?.maxSeq;
     const maxHistoryVersion = rows[0]?.maxHistoryVersion;
     return {
@@ -1682,7 +1910,7 @@ function createSqlConversationEventStore(executor) {
 }
 
 // src/chat/conversations/sql/message-search.ts
-import { and as and5, desc as desc3, eq as eq5, isNull as isNull2, ne, sql as sql5 } from "drizzle-orm";
+import { and as and7, desc as desc3, eq as eq7, isNull as isNull2, ne, sql as sql7 } from "drizzle-orm";
 var EXCERPT_WITHOUT_QUERY_CHARS = 240;
 var SqlConversationMessageSearchStore = class {
   constructor(executor) {
@@ -1692,29 +1920,29 @@ var SqlConversationMessageSearchStore = class {
   async search(args) {
     const db = this.executor.db();
     const query = args.filters.query?.trim() || void 0;
-    const text = sql5`${juniorConversationEvents.payload}->>'text'`;
-    const role = sql5`${juniorConversationEvents.payload}->>'role'`;
-    const messageId = sql5`${juniorConversationEvents.payload}->>'messageId'`;
-    const tsquery = query ? sql5`websearch_to_tsquery('english', ${query})` : void 0;
-    const rank = tsquery ? sql5`ts_rank_cd(to_tsvector('english', ${text}), ${tsquery})` : sql5`1`;
-    const excerpt = tsquery ? sql5`ts_headline('english', ${text}, ${tsquery}, 'MaxFragments=2, MinWords=8, MaxWords=40, FragmentDelimiter=" … ", StartSel=**, StopSel=**')` : sql5`left(${text}, ${EXCERPT_WITHOUT_QUERY_CHARS})`;
+    const text = sql7`${juniorConversationEvents.payload}->>'text'`;
+    const role = sql7`${juniorConversationEvents.payload}->>'role'`;
+    const messageId = sql7`${juniorConversationEvents.payload}->>'messageId'`;
+    const tsquery = query ? sql7`websearch_to_tsquery('english', ${query})` : void 0;
+    const rank = tsquery ? sql7`ts_rank_cd(to_tsvector('english', ${text}), ${tsquery})` : sql7`1`;
+    const excerpt = tsquery ? sql7`ts_headline('english', ${text}, ${tsquery}, 'MaxFragments=2, MinWords=8, MaxWords=40, FragmentDelimiter=" … ", StartSel=**, StopSel=**')` : sql7`left(${text}, ${EXCERPT_WITHOUT_QUERY_CHARS})`;
     const conditions = [
-      eq5(juniorConversations.source, "slack"),
+      eq7(juniorConversations.source, "slack"),
       isNull2(juniorConversations.parentConversationId),
       isNull2(juniorConversations.transcriptPurgedAt),
       ne(juniorConversations.conversationId, args.currentConversationId),
-      eq5(juniorDestinations.provider, args.scope.provider),
-      eq5(juniorDestinations.providerTenantId, args.scope.providerTenantId),
-      eq5(juniorDestinations.visibility, "public"),
-      eq5(juniorConversationEvents.type, "message"),
-      sql5`${role} in ('user', 'assistant')`
+      eq7(juniorDestinations.provider, args.scope.provider),
+      eq7(juniorDestinations.providerTenantId, args.scope.providerTenantId),
+      eq7(juniorDestinations.visibility, "public"),
+      eq7(juniorConversationEvents.type, "message"),
+      sql7`${role} in ('user', 'assistant')`
     ];
     if (tsquery) {
-      conditions.push(sql5`to_tsvector('english', ${text}) @@ ${tsquery}`);
+      conditions.push(sql7`to_tsvector('english', ${text}) @@ ${tsquery}`);
     }
     if (args.filters.channelId) {
       conditions.push(
-        eq5(juniorDestinations.providerDestinationId, args.filters.channelId)
+        eq7(juniorDestinations.providerDestinationId, args.filters.channelId)
       );
     }
     const bestPerConversation = db.selectDistinctOn([juniorConversations.conversationId], {
@@ -1729,14 +1957,14 @@ var SqlConversationMessageSearchStore = class {
       role: role.as("role")
     }).from(juniorConversationEvents).innerJoin(
       juniorConversations,
-      eq5(
+      eq7(
         juniorConversations.conversationId,
         juniorConversationEvents.conversationId
       )
     ).innerJoin(
       juniorDestinations,
-      eq5(juniorDestinations.id, juniorConversations.destinationId)
-    ).where(and5(...conditions)).orderBy(
+      eq7(juniorDestinations.id, juniorConversations.destinationId)
+    ).where(and7(...conditions)).orderBy(
       juniorConversations.conversationId,
       desc3(rank),
       desc3(juniorConversationEvents.createdAt)
@@ -1771,22 +1999,22 @@ function createDb(args) {
   });
 }
 function getSqlExecutor() {
-  const { sql: sql6 } = getChatConfig();
-  if (current?.databaseUrl !== sql6.databaseUrl || current.driver !== sql6.driver || current.statementTimeoutMs !== sql6.statementTimeoutMs) {
+  const { sql: sql8 } = getChatConfig();
+  if (current?.databaseUrl !== sql8.databaseUrl || current.driver !== sql8.driver || current.statementTimeoutMs !== sql8.statementTimeoutMs) {
     if (current) {
       const previous = current;
       current = void 0;
       void previous.db.close().catch(() => void 0);
     }
     const db = createDb({
-      databaseUrl: sql6.databaseUrl,
-      driver: sql6.driver,
-      statementTimeoutMs: sql6.statementTimeoutMs
+      databaseUrl: sql8.databaseUrl,
+      driver: sql8.driver,
+      statementTimeoutMs: sql8.statementTimeoutMs
     });
     current = {
-      databaseUrl: sql6.databaseUrl,
-      driver: sql6.driver,
-      statementTimeoutMs: sql6.statementTimeoutMs,
+      databaseUrl: sql8.databaseUrl,
+      driver: sql8.driver,
+      statementTimeoutMs: sql8.statementTimeoutMs,
       db,
       store: createSqlStore(db),
       eventStore: createSqlConversationEventStore(db),