@sentry/junior 0.202.0 → 0.204.0

package/dist/chunk-M76HMB7M.js

@@ -1,1856 +0,0 @@
-import {
-  conversationReadColumns,
-  createJuniorSqlExecutor,
-  juniorConversationAnnotations,
-  juniorConversationBindings,
-  juniorConversationEvents,
-  juniorConversationParticipants,
-  juniorConversations,
-  juniorIdentities,
-  juniorUsers
-} from "./chunk-PW4P4JYF.js";
-import {
-  conversationEventDataSchema,
-  decodeStoredConversationEvent,
-  historyReplacementSchema,
-  newConversationEventSchema
-} from "./chunk-7NL7T6VU.js";
-import {
-  juniorDestinations
-} from "./chunk-VFUK3X5B.js";
-import {
-  getChatConfig
-} from "./chunk-63NKKFJL.js";
-import {
-  parseActorUserId,
-  parseSlackChannelReferenceId,
-  parseSlackTeamId
-} from "./chunk-N7TMSOZH.js";
-import {
-  normalizeIdentityEmail
-} from "./chunk-MAGNK5J4.js";
-
-// src/chat/conversations/sql/store.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { and as and4, asc, desc, eq as eq4, isNull, sql as sql3 } from "drizzle-orm";
-
-// src/chat/destination.ts
-import {
-  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;
-}
-
-// src/chat/identities/sql.ts
-import { randomUUID } from "crypto";
-import { and, eq, sql } from "drizzle-orm";
-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: sql`coalesce(${juniorUsers.displayName}, excluded.display_name)`,
-      updatedAt: sql`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 upsertIdentityRecord(executor, identity, linkedUserId, nowMs) {
-  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
-  }) : void 0;
-  if (existing?.userId && verifiedUserId && existing.userId !== verifiedUserId) {
-    throw new Error("Identity verified email conflicts with linked user");
-  }
-  if (linkedUserId && verifiedUserId && linkedUserId !== verifiedUserId) {
-    throw new Error("Linked identity conflicts with verified email user");
-  }
-  if (existing?.userId && linkedUserId && existing.userId !== linkedUserId) {
-    throw new Error("Identity conflicts with linked user");
-  }
-  const userId = existing?.userId ?? linkedUserId ?? 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: sql`excluded.kind`,
-      userId: sql`coalesce(${juniorIdentities.userId}, excluded.user_id)`,
-      displayName: linkedUserId ? sql`coalesce(excluded.display_name, ${juniorIdentities.displayName})` : sql`coalesce(${juniorIdentities.displayName}, excluded.display_name)`,
-      handle: linkedUserId ? sql`coalesce(excluded.handle, ${juniorIdentities.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`
-    },
-    ...linkedUserId ? {
-      setWhere: sql`${juniorIdentities.userId} IS NULL OR ${juniorIdentities.userId} = excluded.user_id`
-    } : void 0
-  }).returning({
-    id: juniorIdentities.id,
-    userId: juniorIdentities.userId
-  });
-  const row = rows[0];
-  if (!row) {
-    if (linkedUserId) {
-      throw new Error("Identity conflicts with linked user");
-    }
-    throw new Error("Identity upsert returned no row");
-  }
-  return {
-    id: row.id,
-    ...row.userId ? { userId: row.userId } : void 0
-  };
-}
-async function upsertIdentity(executor, identity, nowMs = Date.now()) {
-  return await upsertIdentityRecord(executor, identity, void 0, nowMs);
-}
-async function upsertLinkedIdentity(executor, userId, identity, nowMs = Date.now()) {
-  return await upsertIdentityRecord(executor, identity, userId, nowMs);
-}
-async function deleteProviderIdentityForSlackUser(executor, slackTeamId, slackUserId, provider, providerSubjectId) {
-  const slackRows = await executor.db().select({ userId: juniorIdentities.userId }).from(juniorIdentities).where(
-    and(
-      eq(juniorIdentities.kind, "user"),
-      eq(juniorIdentities.provider, "slack"),
-      eq(juniorIdentities.providerTenantId, slackTeamId),
-      eq(juniorIdentities.providerSubjectId, slackUserId)
-    )
-  ).limit(1);
-  const userId = slackRows[0]?.userId;
-  if (!userId) return;
-  await executor.db().delete(juniorIdentities).where(
-    and(
-      eq(juniorIdentities.userId, userId),
-      eq(juniorIdentities.provider, provider),
-      eq(juniorIdentities.providerTenantId, ""),
-      eq(juniorIdentities.providerSubjectId, providerSubjectId)
-    )
-  );
-}
-
-// 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)`,
-      ...args.restoreArchive ? { archivedAt: null } : void 0
-    }
-  });
-}
-
-// src/chat/source.ts
-import { sourceSchema } from "@sentry/junior-plugin-api";
-function normalizeSessionSource(value) {
-  if (!value) {
-    return void 0;
-  }
-  if (value.kind === "local") {
-    return {
-      kind: "local",
-      visibility: value.visibility,
-      conversationId: value.conversationId
-    };
-  }
-  if (value.kind === "web") {
-    return {
-      kind: "web",
-      visibility: value.visibility,
-      conversationId: value.conversationId
-    };
-  }
-  if (value.kind === "resource_event" || value.kind === "scheduled_task" || value.kind === "event_task" || value.kind === "plugin_dispatch" || value.kind === "agent_invocation") {
-    return void 0;
-  }
-  const threadTs = value.threadTs?.trim();
-  return {
-    kind: "slack",
-    visibility: value.visibility,
-    teamId: value.teamId,
-    channelId: value.channelId,
-    ...threadTs ? { threadTs } : void 0
-  };
-}
-function parseSessionSource(value) {
-  const parsed = sourceSchema.safeParse(value);
-  return parsed.success ? normalizeSessionSource(parsed.data) : void 0;
-}
-
-// src/chat/conversations/sql/bindings.ts
-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(
-    and3(
-      eq3(juniorConversationBindings.provider, args.provider),
-      eq3(juniorConversationBindings.providerTenantId, args.providerTenantId),
-      eq3(
-        juniorConversationBindings.providerDestinationId,
-        args.providerDestinationId
-      ),
-      eq3(
-        juniorConversationBindings.providerConversationId,
-        args.providerConversationId
-      )
-    )
-  ).limit(1);
-  return rows[0]?.conversationId;
-}
-async function bindProviderConversation(executor, args) {
-  const rows = await executor.db().insert(juniorConversationBindings).values({ ...args, createdAt: /* @__PURE__ */ new Date() }).onConflictDoNothing().returning({ conversationId: juniorConversationBindings.conversationId });
-  const boundConversationId = rows[0]?.conversationId ?? await getConversationIdByProviderConversation(executor, args);
-  if (boundConversationId !== args.conversationId) {
-    throw new Error(
-      "Provider conversation is already bound to another conversation"
-    );
-  }
-}
-
-// src/chat/conversations/sql/actor-identity.ts
-function identityFromActor(actor) {
-  if (actor?.slackUserId) {
-    return {
-      kind: "user",
-      provider: "slack",
-      providerTenantId: actor.teamId,
-      providerSubjectId: actor.slackUserId,
-      ...actor.fullName ? { displayName: actor.fullName } : void 0,
-      ...actor.slackUserName ? { handle: actor.slackUserName } : void 0,
-      ...actor.email ? { email: actor.email, emailVerified: true } : void 0,
-      metadata: { platform: "slack" }
-    };
-  }
-  const email = actor?.email?.trim().toLowerCase();
-  if (!email) {
-    return void 0;
-  }
-  return {
-    kind: "user",
-    provider: "junior",
-    providerSubjectId: email,
-    email,
-    emailVerified: true,
-    ...actor?.fullName ? { displayName: actor.fullName } : void 0,
-    metadata: { platform: "web" }
-  };
-}
-function systemIdentityFromSource(source) {
-  if (source === "scheduler") {
-    return {
-      kind: "system",
-      provider: "junior",
-      providerSubjectId: "scheduler",
-      displayName: "Junior Scheduler"
-    };
-  }
-  if (source === "local") {
-    return {
-      kind: "system",
-      provider: "junior",
-      providerSubjectId: "local-cli",
-      displayName: "Local CLI"
-    };
-  }
-  if (source === "resource_event") {
-    return {
-      kind: "system",
-      provider: "junior",
-      providerSubjectId: "resource-event",
-      displayName: "Resource Event"
-    };
-  }
-  return void 0;
-}
-function actorIdentityForConversation(conversation) {
-  return identityFromActor(conversation.actor) ?? systemIdentityFromSource(conversation.source);
-}
-function actorFromIdentityRow(identity, userDisplayName) {
-  if (!identity) {
-    return void 0;
-  }
-  const fullName = userDisplayName?.trim() ? userDisplayName : identity.displayName;
-  const email = identity.emailNormalized ?? identity.email ?? void 0;
-  if (identity.provider === "slack") {
-    return {
-      ...email ? { email } : void 0,
-      ...fullName ? { fullName } : void 0,
-      platform: "slack",
-      slackUserId: identity.providerSubjectId,
-      ...identity.handle ? { slackUserName: identity.handle } : void 0,
-      ...identity.providerTenantId ? { teamId: identity.providerTenantId } : void 0
-    };
-  }
-  if (identity.provider === "junior" && email) {
-    return {
-      email,
-      ...fullName ? { fullName } : void 0
-    };
-  }
-  return void 0;
-}
-function mergeActor(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 } : void 0,
-    ...current2.fullName ?? next.fullName ? { fullName: current2.fullName ?? next.fullName } : void 0,
-    ...current2.platform ?? next.platform ? { platform: current2.platform ?? next.platform } : void 0,
-    ...current2.slackUserId ?? next.slackUserId ? { slackUserId: current2.slackUserId ?? next.slackUserId } : void 0,
-    ...current2.slackUserName ?? next.slackUserName ? { slackUserName: current2.slackUserName ?? next.slackUserName } : void 0,
-    ...current2.teamId ?? next.teamId ? { teamId: current2.teamId ?? next.teamId } : void 0
-  };
-}
-
-// src/chat/conversations/location.ts
-import { locationSchema } from "@sentry/junior-plugin-api";
-
-// src/chat/conversations/sql/location.ts
-function locationForWrite(args) {
-  const location = args.location ? locationSchema.parse(args.location) : void 0;
-  const destination = args.destination?.platform === "slack" ? args.destination : void 0;
-  const source = args.sessionSource?.kind === "slack" ? args.sessionSource : void 0;
-  if (location) {
-    if (destination && (location.id !== args.destinationId || location.teamId !== destination.teamId || location.channelId !== destination.channelId) || source && (location.teamId !== source.teamId || location.channelId !== source.channelId)) {
-      throw new Error("Conversation Location changed");
-    }
-    return source?.threadTs && !location.threadTs ? { ...location, threadTs: source.threadTs } : location;
-  }
-  if (destination && source && (destination.teamId !== source.teamId || destination.channelId !== source.channelId)) {
-    throw new Error("Conversation Location does not match its session Source");
-  }
-  if (!destination || !args.destinationId) {
-    return void 0;
-  }
-  return locationSchema.parse({
-    id: args.destinationId,
-    provider: "slack",
-    teamId: destination.teamId,
-    channelId: destination.channelId,
-    ...source?.threadTs ? { threadTs: source.threadTs } : void 0
-  });
-}
-function locationFromRow(value, row, sessionSource) {
-  if (value !== void 0 && value !== null) {
-    const location = locationSchema.parse(value);
-    const slackSource2 = !location.threadTs && sessionSource?.kind === "slack" && sessionSource.teamId === location.teamId && sessionSource.channelId === location.channelId ? sessionSource : void 0;
-    return slackSource2?.threadTs ? { ...location, threadTs: slackSource2.threadTs } : location;
-  }
-  if (!row || row.provider === "local") {
-    return void 0;
-  }
-  if (row.provider !== "slack") {
-    throw new Error("Conversation Location provider is not supported");
-  }
-  const slackSource = sessionSource?.kind === "slack" && sessionSource.teamId === row.providerTenantId && sessionSource.channelId === row.providerDestinationId ? sessionSource : void 0;
-  return locationSchema.parse({
-    id: row.id,
-    provider: "slack",
-    teamId: row.providerTenantId,
-    channelId: row.providerDestinationId,
-    ...slackSource?.threadTs ? { threadTs: slackSource.threadTs } : void 0
-  });
-}
-function visibilityFromLocationRow(row) {
-  if (!row) {
-    return void 0;
-  }
-  if (row.visibility === "public" || row.visibility === "private") {
-    return row.visibility;
-  }
-  return void 0;
-}
-
-// src/chat/conversations/sql/store.ts
-var CONVERSATION_MUTATION_LOCK_PREFIX = "junior_conversation";
-async function withConversationMutationLock(executor, conversationId, callback) {
-  return await executor.withLock(
-    `${CONVERSATION_MUTATION_LOCK_PREFIX}:${conversationId}`,
-    async () => await executor.transaction(callback)
-  );
-}
-function now() {
-  return Date.now();
-}
-function dateFromMs2(ms) {
-  return new Date(ms);
-}
-function msFromDate(value) {
-  if (value === null || value === void 0) {
-    return void 0;
-  }
-  const date = value instanceof Date ? value : new Date(value);
-  return date.getTime();
-}
-function requiredMsFromDate(value) {
-  const ms = msFromDate(value);
-  if (typeof ms !== "number" || Number.isNaN(ms)) {
-    throw new Error("Conversation record timestamp is invalid");
-  }
-  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" || value === "web") {
-    return value;
-  }
-  return void 0;
-}
-function originTypeFromSource(source) {
-  return source;
-}
-function localWorkspaceFromConversationId(conversationId) {
-  const match = /^local:([^:]+):/.exec(conversationId);
-  return match?.[1];
-}
-function destinationUpsertFromDestination(args) {
-  const { destination } = args;
-  if (!destination) {
-    return void 0;
-  }
-  if (destination.platform === "slack") {
-    const channelId = destination.channelId;
-    const channelKind = channelId.startsWith("D") ? "dm" : channelId.startsWith("G") ? "group" : "channel";
-    return {
-      kind: channelKind,
-      provider: "slack",
-      providerTenantId: destination.teamId,
-      providerDestinationId: channelId,
-      refreshVisibility: args.visibility !== void 0,
-      visibility: args.visibility ?? "unknown",
-      ...args.channelName ? { displayName: args.channelName } : void 0,
-      metadata: { platform: "slack" }
-    };
-  }
-  return {
-    kind: "local_conversation",
-    provider: "local",
-    providerTenantId: localWorkspaceFromConversationId(destination.conversationId) ?? localWorkspaceFromConversationId(args.conversationId ?? ""),
-    providerDestinationId: destination.conversationId,
-    // Match Slack: only refresh when a live visibility signal is present so
-    // execution-metadata writes cannot clobber public dashboard roots.
-    refreshVisibility: args.visibility !== void 0,
-    visibility: args.visibility ?? "direct",
-    metadata: { platform: "local" }
-  };
-}
-function executionStatusFromValue(value) {
-  if (value === "awaiting_resume" || value === "paused") return "paused";
-  if (value === "failed" || value === "idle" || value === "pending" || value === "running") {
-    return value;
-  }
-  throw new Error("Conversation record execution status is invalid");
-}
-function executionStatusToSql(status) {
-  return status === "paused" ? "awaiting_resume" : status;
-}
-function destinationFromRow(destination) {
-  const value = destination?.provider === "slack" ? {
-    platform: "slack",
-    teamId: destination.providerTenantId,
-    channelId: destination.providerDestinationId
-  } : destination?.provider === "local" ? {
-    platform: "local",
-    conversationId: destination.providerDestinationId
-  } : void 0;
-  return parseDestination(value);
-}
-function conversationFromRow(readRow) {
-  const row = readRow.conversation;
-  const visibility = visibilityFromLocationRow(readRow.destination);
-  if (row.schemaVersion !== 1) {
-    throw new Error("Conversation record schema version is invalid");
-  }
-  if (row.destination !== null && readRow.destination === null) {
-    throw new Error("Conversation legacy destination is not migrated");
-  }
-  if (row.actor !== null && readRow.actorIdentity === null) {
-    throw new Error("Conversation legacy actor is not migrated");
-  }
-  const destination = destinationFromRow(readRow.destination);
-  const actor = actorFromIdentityRow(
-    readRow.actorIdentity,
-    readRow.actorUserDisplayName
-  );
-  if (readRow.destination !== null && !destination) {
-    throw new Error("Conversation record destination is invalid");
-  }
-  const source = row.source === void 0 || row.source === null ? void 0 : sourceFromValue(row.source);
-  if (row.source !== void 0 && row.source !== null && !source) {
-    throw new Error("Conversation record source is invalid");
-  }
-  const sessionSource = row.sessionSource === void 0 || row.sessionSource === null ? void 0 : parseSessionSource(row.sessionSource);
-  if (row.sessionSource !== void 0 && row.sessionSource !== null && !sessionSource) {
-    throw new Error("Conversation record session source is invalid");
-  }
-  const execution = {
-    status: executionStatusFromValue(row.executionStatus),
-    lastCheckpointAtMs: msFromDate(row.lastCheckpointAt),
-    lastEnqueuedAtMs: msFromDate(row.lastEnqueuedAt),
-    ...row.runId ? { runId: row.runId } : void 0,
-    updatedAtMs: msFromDate(row.executionUpdatedAt) ?? requiredMsFromDate(row.updatedAt)
-  };
-  const location = locationFromRow(
-    row.location,
-    readRow.destination,
-    sessionSource
-  );
-  return {
-    schemaVersion: 1,
-    conversationId: row.conversationId,
-    createdAtMs: requiredMsFromDate(row.createdAt),
-    lastActivityAtMs: requiredMsFromDate(row.lastActivityAt),
-    updatedAtMs: requiredMsFromDate(row.updatedAt),
-    execution,
-    executionMetrics: {
-      durationMs: row.executionDurationMs,
-      ...row.metricRunId ? { runId: row.metricRunId } : void 0,
-      ...row.executionUsage ? { usage: row.executionUsage } : void 0
-    },
-    ...row.parentConversationId ? { parentConversationId: row.parentConversationId } : void 0,
-    ...destination ? { destination } : void 0,
-    ...location ? { location } : void 0,
-    ...actor ? { actor } : void 0,
-    ...row.channelName ? { channelName: row.channelName } : void 0,
-    ...source ? { source } : void 0,
-    ...sessionSource ? { sessionSource } : void 0,
-    ...row.title ? { title: row.title } : void 0,
-    ...msFromDate(row.transcriptPurgedAt) !== void 0 ? { transcriptPurgedAtMs: msFromDate(row.transcriptPurgedAt) } : void 0,
-    ...visibility ? { visibility } : void 0
-  };
-}
-function emptyConversation(args) {
-  return {
-    schemaVersion: 1,
-    conversationId: args.conversationId,
-    createdAtMs: args.nowMs,
-    lastActivityAtMs: args.nowMs,
-    updatedAtMs: args.nowMs,
-    ...args.destination ? { destination: args.destination } : void 0,
-    ...args.source ? { source: args.source } : void 0,
-    ...args.sessionSource ? { sessionSource: args.sessionSource } : void 0,
-    execution: {
-      status: "idle",
-      updatedAtMs: args.nowMs
-    }
-  };
-}
-function assertSameConversationDestination(args) {
-  if (!args.current || sameDestination(args.current, args.next)) {
-    return;
-  }
-  throw new Error(
-    `Conversation destination changed for ${args.conversationId}`
-  );
-}
-function tokenTotal(usage) {
-  if (!usage) return 0;
-  if (usage.totalTokens !== void 0) return usage.totalTokens;
-  return (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0) + (usage.cachedInputTokens ?? 0) + (usage.cacheCreationTokens ?? 0);
-}
-function updateConversationUsage(args) {
-  const usage = {
-    totalTokens: tokenTotal(args.current) - tokenTotal(args.previousExecution) + tokenTotal(args.nextExecution)
-  };
-  if (args.current?.reasoningTokens !== void 0 || args.previousExecution?.reasoningTokens !== void 0 || args.nextExecution.reasoningTokens !== void 0) {
-    usage.reasoningTokens = (args.current?.reasoningTokens ?? 0) - (args.previousExecution?.reasoningTokens ?? 0) + (args.nextExecution.reasoningTokens ?? 0);
-  }
-  const costFields = [
-    "input",
-    "output",
-    "cacheRead",
-    "cacheWrite",
-    "total"
-  ];
-  const cost = {};
-  for (const field of costFields) {
-    if (args.current?.cost?.[field] === void 0 && args.previousExecution?.cost?.[field] === void 0 && args.nextExecution.cost?.[field] === void 0) {
-      continue;
-    }
-    cost[field] = Math.round(
-      ((args.current?.cost?.[field] ?? 0) - (args.previousExecution?.cost?.[field] ?? 0) + (args.nextExecution.cost?.[field] ?? 0)) * 1e12
-    ) / 1e12;
-  }
-  if (Object.keys(cost).length > 0) usage.cost = cost;
-  return usage;
-}
-var SqlStore = class {
-  constructor(executor) {
-    this.executor = executor;
-  }
-  executor;
-  async getConversationIdByProviderConversation(args) {
-    return await getConversationIdByProviderConversation(this.executor, args);
-  }
-  async bindProviderConversation(args) {
-    await bindProviderConversation(this.executor, args);
-  }
-  async createChild(args) {
-    const nowMs = args.nowMs ?? now();
-    await this.withConversationMutation(args.parentConversationId, async () => {
-      await this.withConversationMutation(
-        args.childConversationId,
-        async () => {
-          const existing = await this.get({
-            conversationId: args.childConversationId
-          });
-          if (existing) {
-            if (existing.parentConversationId !== args.parentConversationId) {
-              throw new Error(
-                `Conversation parent changed for ${args.childConversationId}`
-              );
-            }
-            return;
-          }
-          const parent = await this.get({
-            conversationId: args.parentConversationId
-          });
-          if (!parent) {
-            throw new Error(
-              `Conversation parent is missing for ${args.childConversationId}`
-            );
-          }
-          if (parent.parentConversationId) {
-            throw new Error("Recursive agent delegation is not enabled");
-          }
-          const child = {
-            ...emptyConversation({
-              conversationId: args.childConversationId,
-              nowMs,
-              source: args.source
-            }),
-            parentConversationId: args.parentConversationId
-          };
-          await this.upsertConversation({ conversation: child });
-        }
-      );
-    });
-  }
-  async get(args) {
-    const row = await this.readConversationRow(args.conversationId);
-    if (!row) {
-      return void 0;
-    }
-    return conversationFromRow(row);
-  }
-  async recordActivity(args) {
-    const nowMs = args.nowMs ?? now();
-    const activityAtMs = args.activityAtMs ?? nowMs;
-    const sessionSource = normalizeSessionSource(args.sessionSource);
-    await this.withConversationMutation(args.conversationId, async () => {
-      const existing = await this.get({
-        conversationId: args.conversationId
-      });
-      if (existing && args.destination) {
-        assertSameConversationDestination({
-          conversationId: args.conversationId,
-          current: existing.destination,
-          next: args.destination
-        });
-      }
-      const current2 = existing ?? emptyConversation({
-        conversationId: args.conversationId,
-        destination: args.destination,
-        nowMs,
-        source: args.source,
-        ...sessionSource ? { sessionSource } : void 0
-      });
-      const {
-        sessionSource: _persistedSessionSource,
-        visibility: _persistedVisibility,
-        ...currentWithoutPersistedSignals
-      } = current2;
-      await this.upsertConversation({
-        conversation: {
-          ...currentWithoutPersistedSignals,
-          destination: current2.destination ?? args.destination,
-          source: current2.source ?? args.source,
-          ...sessionSource ? { sessionSource } : void 0,
-          channelName: current2.channelName ?? args.channelName,
-          actor: mergeActor(current2.actor, args.actor),
-          title: current2.title ?? args.title,
-          lastActivityAtMs: Math.max(current2.lastActivityAtMs, activityAtMs),
-          updatedAtMs: nowMs,
-          execution: {
-            ...current2.execution,
-            updatedAtMs: current2.execution.updatedAtMs ?? nowMs
-          },
-          ...args.visibility ? { visibility: args.visibility } : void 0
-        }
-      });
-    });
-  }
-  async recordExecution(args) {
-    await this.withConversationMutation(args.conversationId, async () => {
-      const existingRow = await this.readConversationRow(args.conversationId);
-      const existing = existingRow ? conversationFromRow(existingRow) : void 0;
-      if (!existing && !args.destination) {
-        return;
-      }
-      const incomingExecutionAt = args.execution.updatedAtMs ?? args.updatedAtMs;
-      const existingExecutionAt = existing?.execution.updatedAtMs ?? existing?.updatedAtMs ?? 0;
-      const incomingIsFresh = incomingExecutionAt >= existingExecutionAt;
-      const metricRunId = existingRow?.conversation.metricRunId;
-      const sameRun = Boolean(metricRunId) && metricRunId === args.execution.runId;
-      const execution = incomingIsFresh ? args.execution : existing?.execution ?? args.execution;
-      await this.upsertConversation({
-        conversation: {
-          schemaVersion: 1,
-          conversationId: args.conversationId,
-          createdAtMs: args.createdAtMs,
-          lastActivityAtMs: args.lastActivityAtMs,
-          updatedAtMs: args.updatedAtMs,
-          ...existing?.parentConversationId ? { parentConversationId: existing.parentConversationId } : void 0,
-          ...existing?.location ? { location: existing.location } : void 0,
-          ...args.channelName ? { channelName: args.channelName } : void 0,
-          ...args.destination ? { destination: args.destination } : void 0,
-          ...args.actor ? { actor: args.actor } : void 0,
-          ...args.source ? { source: args.source } : void 0,
-          ...args.title ? { title: args.title } : void 0,
-          ...args.visibility ? { visibility: args.visibility } : void 0,
-          execution
-        }
-      });
-      if (incomingIsFresh && args.metrics) {
-        const row = existingRow?.conversation;
-        const usage = args.metrics.usage ? updateConversationUsage({
-          current: row?.usage ?? void 0,
-          previousExecution: sameRun ? row?.executionUsage ?? void 0 : void 0,
-          nextExecution: args.metrics.usage
-        }) : row?.usage ?? void 0;
-        await this.executor.db().update(juniorConversations).set({
-          durationMs: (row?.durationMs ?? 0) - (sameRun ? row?.executionDurationMs ?? 0 : 0) + args.metrics.durationMs,
-          usage: usage ?? null,
-          metricRunId: args.execution.runId ?? null,
-          executionDurationMs: args.metrics.durationMs,
-          executionUsage: args.metrics.usage ?? (sameRun ? row?.executionUsage ?? null : null)
-        }).where(eq4(juniorConversations.conversationId, args.conversationId));
-      }
-    });
-  }
-  async listByActivity(args = {}) {
-    const rows = await this.executor.db().select({
-      conversation: conversationReadColumns(),
-      destination: juniorDestinations,
-      actorIdentity: juniorIdentities,
-      actorUserDisplayName: juniorUsers.displayName
-    }).from(juniorConversations).leftJoin(
-      juniorDestinations,
-      eq4(juniorDestinations.id, juniorConversations.destinationId)
-    ).leftJoin(
-      juniorIdentities,
-      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));
-    const conversations = [];
-    for (const row of rows) {
-      conversations.push(conversationFromRow(row));
-    }
-    return conversations;
-  }
-  async getDestinationVisibility(args) {
-    const rows = await this.executor.db().select({
-      visibility: juniorDestinations.visibility
-    }).from(juniorDestinations).where(
-      and4(
-        eq4(juniorDestinations.provider, args.provider),
-        eq4(
-          juniorDestinations.providerTenantId,
-          tenantId2(args.providerTenantId)
-        ),
-        eq4(
-          juniorDestinations.providerDestinationId,
-          args.providerDestinationId
-        )
-      )
-    );
-    const row = rows[0];
-    if (!row) {
-      return void 0;
-    }
-    if (row.visibility === "public" || row.visibility === "private") {
-      return row.visibility;
-    }
-    return void 0;
-  }
-  async findSlackDestinationByName(args) {
-    const normalized = args.channelName.trim().replace(/^#/, "").toLowerCase();
-    if (!normalized) {
-      return void 0;
-    }
-    const rows = await this.executor.db().select({
-      channelId: juniorDestinations.providerDestinationId,
-      channelName: juniorDestinations.displayName
-    }).from(juniorDestinations).where(
-      and4(
-        eq4(juniorDestinations.provider, "slack"),
-        eq4(juniorDestinations.providerTenantId, tenantId2(args.teamId)),
-        eq4(juniorDestinations.kind, "channel"),
-        sql3`lower(ltrim(${juniorDestinations.displayName}, '#')) = ${normalized}`
-      )
-    ).limit(2);
-    if (rows.length !== 1) {
-      return void 0;
-    }
-    const row = rows[0];
-    if (!row?.channelId) {
-      return void 0;
-    }
-    return {
-      channelId: row.channelId,
-      ...row.channelName ? { channelName: row.channelName } : void 0
-    };
-  }
-  /** Serialize all durable mutations for one conversation inside a SQL transaction. */
-  async withConversationMutation(conversationId, callback) {
-    return await withConversationMutationLock(
-      this.executor,
-      conversationId,
-      callback
-    );
-  }
-  async readConversationRow(conversationId) {
-    const rows = await this.executor.db().select({
-      conversation: conversationReadColumns(),
-      destination: juniorDestinations,
-      actorIdentity: juniorIdentities,
-      actorUserDisplayName: juniorUsers.displayName
-    }).from(juniorConversations).leftJoin(
-      juniorDestinations,
-      eq4(juniorDestinations.id, juniorConversations.destinationId)
-    ).leftJoin(
-      juniorIdentities,
-      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;
-    if (!conversation.parentConversationId && !conversation.destination) {
-      const existing = await this.get({
-        conversationId: conversation.conversationId
-      });
-      if (!existing) {
-        throw new Error(
-          `Conversation ${conversation.conversationId} requires a destination at create`
-        );
-      }
-    }
-    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,
-        conversationId: conversation.conversationId,
-        destination: conversation.destination,
-        ...conversation.visibility ? { visibility: conversation.visibility } : void 0
-      }),
-      conversation.updatedAtMs
-    );
-    const location = locationForWrite({
-      destination: conversation.destination,
-      destinationId,
-      location: conversation.location,
-      sessionSource: conversation.sessionSource
-    });
-    const actorIdentityObservation = actorIdentityForConversation(conversation);
-    const actorIdentity = actorIdentityObservation ? await upsertIdentity(
-      this.executor,
-      actorIdentityObservation,
-      conversation.updatedAtMs
-    ) : void 0;
-    const rootConversationId = conversation.parentConversationId ? sql3`(
-          select parent.root_conversation_id
-          from junior_conversations parent
-          where parent.conversation_id = ${conversation.parentConversationId}
-        )` : conversation.conversationId;
-    const rows = await this.executor.db().insert(juniorConversations).values({
-      conversationId: conversation.conversationId,
-      schemaVersion: 1,
-      source: conversation.source ?? null,
-      sessionSource: conversation.sessionSource ?? null,
-      originType: originTypeFromSource(conversation.source) ?? null,
-      originId: null,
-      originRunId: null,
-      location: location ?? null,
-      destinationId: destinationId ?? null,
-      destination: null,
-      actorIdentityId: actorIdentity?.id ?? null,
-      creatorIdentityId: null,
-      credentialSubjectIdentityId: null,
-      actor: null,
-      channelName: conversation.channelName ?? null,
-      title: conversation.title ?? null,
-      createdAt: dateFromMs2(conversation.createdAtMs),
-      lastActivityAt: dateFromMs2(conversation.lastActivityAtMs),
-      updatedAt: dateFromMs2(conversation.updatedAtMs),
-      executionUpdatedAt: conversation.execution.updatedAtMs === void 0 ? null : dateFromMs2(conversation.execution.updatedAtMs),
-      executionStatus: executionStatusToSql(conversation.execution.status),
-      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.parentConversationId ?? null,
-      rootConversationId
-    }).onConflictDoUpdate({
-      target: juniorConversations.conversationId,
-      set: {
-        // Origin source is set-once so dashboard continues cannot rewrite a Slack root.
-        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})`,
-        location: sql3`coalesce(excluded.location_json, ${juniorConversations.location})`,
-        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
-    });
-    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 ? sql3`excluded.visibility` : juniorDestinations.visibility;
-    const rows = await this.executor.db().insert(juniorDestinations).values({
-      id: randomUUID2(),
-      provider: destination.provider,
-      providerTenantId: tenantId2(destination.providerTenantId),
-      providerDestinationId: destination.providerDestinationId,
-      kind: destination.kind,
-      parentDestinationId: null,
-      displayName: destination.displayName ?? null,
-      visibility: destination.visibility,
-      metadata: destination.metadata ?? null,
-      createdAt: dateFromMs2(nowMs),
-      updatedAt: dateFromMs2(nowMs)
-    }).onConflictDoUpdate({
-      target: [
-        juniorDestinations.provider,
-        juniorDestinations.providerTenantId,
-        juniorDestinations.providerDestinationId
-      ],
-      set: {
-        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: sql3`coalesce(excluded.metadata_json, ${juniorDestinations.metadata})`,
-        updatedAt: sql3`excluded.updated_at`
-      }
-    }).returning({ id: juniorDestinations.id });
-    return rows[0]?.id;
-  }
-};
-function createSqlStore(executor) {
-  return new SqlStore(executor);
-}
-
-// src/chat/conversations/sql/history.ts
-import {
-  and as and6,
-  asc as asc2,
-  desc as desc2,
-  eq as eq6,
-  gt,
-  gte,
-  inArray as inArray2,
-  lt,
-  lte,
-  sql as sql6
-} from "drizzle-orm";
-
-// src/chat/conversations/sql/conversation-row.ts
-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({
-    conversationId,
-    createdAt: at,
-    lastActivityAt: at,
-    updatedAt: at,
-    executionStatus: "idle"
-  });
-  if (options.activity === "preserve") {
-    await insert.onConflictDoNothing({
-      target: juniorConversations.conversationId
-    });
-    return;
-  }
-  await insert.onConflictDoUpdate({
-    target: juniorConversations.conversationId,
-    set: {
-      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 } : void 0,
-    ...typeof author.fullName === "string" ? { fullName: author.fullName } : void 0,
-    ...typeof author.isBot === "boolean" ? { isBot: author.isBot } : void 0,
-    ...typeof author.userId === "string" ? { userId: author.userId } : void 0,
-    ...typeof author.userName === "string" ? { userName: author.userName } : void 0
-  };
-}
-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 = parseSessionSource(row?.sessionSource);
-  if (sessionSource?.kind === "slack") {
-    return sessionSource.teamId;
-  }
-  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 } : void 0,
-      ...author.fullName ? { displayName: author.fullName } : void 0,
-      ...author.userName ? { handle: author.userName } : void 0,
-      ...author.email ? { email: author.email, emailVerified: true } : void 0
-    };
-    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 } : void 0,
-        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") {
-    return value.replaceAll("\0", " ");
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => sanitizePostgresJson(item));
-  }
-  if (value === null || typeof value !== "object") {
-    return value;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype !== Object.prototype && prototype !== null) {
-    return value;
-  }
-  return Object.fromEntries(
-    Object.entries(value).map(([key, item]) => [
-      key,
-      sanitizePostgresJson(item)
-    ])
-  );
-}
-
-// src/chat/conversations/sql/event-lock.ts
-async function withConversationEventLock(executor, conversationId, callback) {
-  return executor.withLock(`junior_conversation:${conversationId}`, callback);
-}
-
-// src/chat/conversations/sql/history.ts
-var messageHistoryEventTypes = [
-  "message",
-  "message_updated",
-  "message_handled"
-];
-var HUMAN_INSTRUCTION_PLATFORMS = /* @__PURE__ */ new Set(["slack", "local", "web"]);
-function eventUnarchivesConversation(data) {
-  if (data.type === "user_message") {
-    const provenance = data.provenance;
-    if (provenance.authority !== "instruction") return false;
-    const platform = provenance.actor?.platform;
-    return platform === void 0 || HUMAN_INSTRUCTION_PLATFORMS.has(platform);
-  }
-  if (data.type !== "message") {
-    return false;
-  }
-  if (data.role !== "user") return false;
-  const meta = data.meta;
-  if (!meta) return true;
-  if (typeof meta.eventType === "string" && meta.eventType.length > 0) {
-    return false;
-  }
-  const author = meta.author;
-  if (author && typeof author === "object" && !Array.isArray(author) && author.isBot === true) {
-    return false;
-  }
-  return true;
-}
-function insertFromEvent(conversationId, seq, historyVersion, event, actorIdentityId) {
-  const stripped = stripPayloadAuthorIdentityId(event.data);
-  const { type, ...payload } = conversationEventDataSchema.parse(stripped);
-  return {
-    conversationId,
-    seq,
-    historyVersion,
-    schemaVersion: 1,
-    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,
-    historyVersion: row.historyVersion,
-    ...row.idempotencyKey ? { idempotencyKey: row.idempotencyKey } : void 0,
-    createdAtMs: row.createdAt.getTime(),
-    type: row.type,
-    payload
-  });
-}
-function messagesSummarizedEventFromRow(row) {
-  const event = eventFromRow(row);
-  if (event.schemaVersion !== 1 || event.data.type !== "messages_summarized") {
-    throw new Error(
-      "Message compaction row did not decode as messages_summarized"
-    );
-  }
-  return { ...event, schemaVersion: 1, data: event.data };
-}
-var SqlConversationEventStore = class {
-  constructor(executor) {
-    this.executor = executor;
-  }
-  executor;
-  async append(conversationId, events, options = {}) {
-    const parsed = events.map(
-      (event) => newConversationEventSchema.parse(event)
-    );
-    if (parsed.length === 0) {
-      return [];
-    }
-    return withConversationEventLock(
-      this.executor,
-      conversationId,
-      async () => {
-        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(
-            and6(
-              eq6(
-                juniorConversationEvents.conversationId,
-                conversationId
-              ),
-              inArray2(
-                juniorConversationEvents.idempotencyKey,
-                existingKeys
-              )
-            )
-          )).flatMap((row) => row.key ? [row.key] : [])
-        );
-        const acceptedKeys = new Set(persistedKeys);
-        const pending = parsed.filter((event) => {
-          if (event.idempotencyKey === void 0) return true;
-          if (acceptedKeys.has(event.idempotencyKey)) return false;
-          acceptedKeys.add(event.idempotencyKey);
-          return true;
-        });
-        if (pending.length === 0) {
-          return [];
-        }
-        const newestCreatedAtMs = Math.max(
-          ...pending.map((event) => event.createdAtMs)
-        );
-        await ensureConversationRow(
-          this.executor,
-          conversationId,
-          newestCreatedAtMs,
-          options
-        );
-        const cursor = await this.readCursor(conversationId);
-        const historyVersion = cursor.maxHistoryVersion ?? 0;
-        let seq = cursor.nextSeq;
-        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,
-              restoreArchive: eventUnarchivesConversation(event.data)
-            });
-          }
-        }
-        await this.executor.db().insert(juniorConversationEvents).values(rows);
-        return rows.map((row) => ({
-          seq: row.seq,
-          historyVersion: row.historyVersion
-        }));
-      }
-    );
-  }
-  async replaceHistory(conversationId, replacement) {
-    const parsed = historyReplacementSchema.parse(replacement);
-    await withConversationEventLock(this.executor, conversationId, async () => {
-      await ensureConversationRow(this.executor, conversationId, Date.now());
-      const cursor = await this.readCursor(conversationId);
-      const historyVersion = (cursor.maxHistoryVersion ?? 0) + 1;
-      await this.executor.db().insert(juniorConversationEvents).values(
-        insertFromEvent(
-          conversationId,
-          cursor.nextSeq,
-          historyVersion,
-          parsed
-        )
-      );
-    });
-  }
-  async loadCurrentHistoryVersion(conversationId) {
-    return (await this.readCursor(conversationId)).maxHistoryVersion ?? 0;
-  }
-  async loadCurrentHistory(conversationId) {
-    const cursor = await this.readCursor(conversationId);
-    if (cursor.maxHistoryVersion === null) {
-      return [];
-    }
-    const rows = await this.executor.db().select().from(juniorConversationEvents).where(
-      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(
-      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(
-      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(
-      and6(
-        eq6(juniorConversationEvents.conversationId, conversationId),
-        eq6(juniorConversationEvents.historyVersion, boundary.historyVersion),
-        throughSeq === void 0 ? void 0 : lte(juniorConversationEvents.seq, throughSeq)
-      )
-    ).orderBy(asc2(juniorConversationEvents.seq));
-    return rows.map(eventFromRow);
-  }
-  async loadLatestStructuredEvent(conversationId, namespace, name) {
-    const [row] = await this.executor.db().select().from(juniorConversationEvents).where(
-      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(
-      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(
-      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(
-      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(eq6(juniorConversationEvents.conversationId, conversationId)).orderBy(asc2(juniorConversationEvents.seq));
-    return rows.map(eventFromRow);
-  }
-  async query(conversationId, query) {
-    if (query.limit < 1) {
-      throw new Error("Conversation event query limit must be at least 1");
-    }
-    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 ? 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
-    );
-    const newestFirst = query.afterSeq === void 0;
-    const rows = await this.executor.db().select().from(juniorConversationEvents).where(bounds).orderBy(
-      newestFirst ? desc2(juniorConversationEvents.seq) : asc2(juniorConversationEvents.seq)
-    ).limit(query.limit + 1);
-    const overflow = rows.length > query.limit;
-    const pageRows = overflow ? rows.slice(0, query.limit) : rows;
-    const events = (newestFirst ? [...pageRows].reverse() : pageRows).map(
-      eventFromRow
-    );
-    if (events.length === 0) {
-      return { events, hasOlder: false, hasNewer: false };
-    }
-    const firstSeq = events[0].seq;
-    const lastSeq = events[events.length - 1].seq;
-    const hasOlder = newestFirst && overflow ? true : await this.hasMatchingEvent({
-      conversationId,
-      beforeSeq: firstSeq,
-      typeFilter
-    });
-    const hasNewer = !newestFirst && overflow ? true : await this.hasMatchingEvent({
-      conversationId,
-      afterSeq: lastSeq,
-      typeFilter
-    });
-    return { events, hasOlder, hasNewer };
-  }
-  /** Return whether any matching event exists inside the exclusive seq window. */
-  async hasMatchingEvent(args) {
-    if (args.afterSeq !== void 0 && args.beforeSeq !== void 0 && args.afterSeq >= args.beforeSeq) {
-      return false;
-    }
-    const [row] = await this.executor.db().select({ seq: juniorConversationEvents.seq }).from(juniorConversationEvents).where(
-      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
-      )
-    ).limit(1);
-    return row !== void 0;
-  }
-  /** Read the next sequence and active model-history version. */
-  async readCursor(conversationId) {
-    const rows = await this.executor.db().select({
-      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 {
-      maxHistoryVersion: maxHistoryVersion === null || maxHistoryVersion === void 0 ? null : Number(maxHistoryVersion),
-      nextSeq: maxSeq === null || maxSeq === void 0 ? 0 : Number(maxSeq) + 1
-    };
-  }
-};
-function createSqlConversationEventStore(executor) {
-  return new SqlConversationEventStore(executor);
-}
-
-// src/chat/conversations/sql/message-search.ts
-import {
-  and as and7,
-  desc as desc3,
-  eq as eq7,
-  gte as gte2,
-  isNull as isNull2,
-  lt as lt2,
-  ne,
-  sql as sql7
-} from "drizzle-orm";
-var EXCERPT_WITHOUT_QUERY_CHARS = 240;
-var SqlConversationMessageSearchStore = class {
-  constructor(executor) {
-    this.executor = executor;
-  }
-  executor;
-  async search(args) {
-    const db = this.executor.db();
-    const query = args.filters.query?.trim() || void 0;
-    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 = [
-      eq7(juniorConversations.source, "slack"),
-      isNull2(juniorConversations.parentConversationId),
-      isNull2(juniorConversations.transcriptPurgedAt),
-      ne(juniorConversations.conversationId, args.currentConversationId),
-      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(sql7`to_tsvector('english', ${text}) @@ ${tsquery}`);
-    }
-    if (args.filters.channelId) {
-      conditions.push(
-        eq7(juniorDestinations.providerDestinationId, args.filters.channelId)
-      );
-    }
-    if (args.filters.afterMs !== void 0 && Number.isFinite(args.filters.afterMs)) {
-      conditions.push(
-        gte2(juniorConversations.lastActivityAt, new Date(args.filters.afterMs))
-      );
-    }
-    if (args.filters.beforeMs !== void 0 && Number.isFinite(args.filters.beforeMs)) {
-      conditions.push(
-        lt2(juniorConversations.lastActivityAt, new Date(args.filters.beforeMs))
-      );
-    }
-    if (args.filters.annotation) {
-      const annotation = args.filters.annotation.toLowerCase();
-      const nestedAnnotationPrefix = `${annotation}#`;
-      conditions.push(
-        sql7`exists (
-          select 1
-          from ${juniorConversationAnnotations}
-          where ${and7(
-          eq7(
-            juniorConversationAnnotations.conversationId,
-            juniorConversations.conversationId
-          ),
-          // Exact key, or a nested child that continues with "#".
-          // Avoids sibling key collisions and partial nested-id prefixes.
-          sql7`(
-              lower(${juniorConversationAnnotations.key}) = ${annotation}
-              or starts_with(
-                lower(${juniorConversationAnnotations.key}),
-                ${nestedAnnotationPrefix}
-              )
-            )`
-        )}
-        )`
-      );
-    }
-    const bestPerConversation = db.selectDistinctOn([juniorConversations.conversationId], {
-      channelName: juniorDestinations.displayName,
-      conversationId: juniorConversations.conversationId,
-      excerpt: excerpt.as("excerpt"),
-      lastActivityAt: juniorConversations.lastActivityAt,
-      messageCreatedAt: juniorConversationEvents.createdAt,
-      messageId: messageId.as("message_id"),
-      providerDestinationId: juniorDestinations.providerDestinationId,
-      rank: rank.as("rank"),
-      role: role.as("role")
-    }).from(juniorConversationEvents).innerJoin(
-      juniorConversations,
-      eq7(
-        juniorConversations.conversationId,
-        juniorConversationEvents.conversationId
-      )
-    ).innerJoin(
-      juniorDestinations,
-      eq7(juniorDestinations.id, juniorConversations.destinationId)
-    ).where(and7(...conditions)).orderBy(
-      juniorConversations.conversationId,
-      desc3(rank),
-      desc3(juniorConversationEvents.createdAt)
-    ).as("best_conversation_matches");
-    const rows = await db.select().from(bestPerConversation).orderBy(
-      desc3(bestPerConversation.rank),
-      desc3(bestPerConversation.lastActivityAt),
-      desc3(bestPerConversation.messageCreatedAt)
-    ).limit(args.limit);
-    return rows.map((row) => ({
-      conversationId: row.conversationId,
-      excerpt: row.excerpt,
-      messageCreatedAtMs: row.messageCreatedAt.getTime(),
-      messageId: row.messageId,
-      providerDestinationId: row.providerDestinationId,
-      role: row.role,
-      ...row.channelName ? { channelName: row.channelName } : void 0
-    }));
-  }
-};
-function createSqlConversationMessageSearchStore(executor) {
-  return new SqlConversationMessageSearchStore(executor);
-}
-
-// src/chat/db.ts
-var current;
-function createDb(args) {
-  return createJuniorSqlExecutor({
-    connectionString: args.databaseUrl,
-    driver: args.driver,
-    statementTimeoutMs: args.statementTimeoutMs
-  });
-}
-function getSqlExecutor() {
-  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: sql8.databaseUrl,
-      driver: sql8.driver,
-      statementTimeoutMs: sql8.statementTimeoutMs
-    });
-    current = {
-      databaseUrl: sql8.databaseUrl,
-      driver: sql8.driver,
-      statementTimeoutMs: sql8.statementTimeoutMs,
-      db,
-      store: createSqlStore(db),
-      eventStore: createSqlConversationEventStore(db),
-      searchStore: createSqlConversationMessageSearchStore(db)
-    };
-  }
-  return current.db;
-}
-function getDb() {
-  return getSqlExecutor().db();
-}
-function getConversationStore() {
-  getSqlExecutor();
-  return current.store;
-}
-function getConversationEventStore() {
-  getSqlExecutor();
-  return current.eventStore;
-}
-function getConversationMessageSearchStore() {
-  getSqlExecutor();
-  return current.searchStore;
-}
-async function closeDb() {
-  const previous = current;
-  current = void 0;
-  await previous?.db.close();
-}
-
-export {
-  createSlackDestination,
-  parseDestination,
-  requireSlackDestination,
-  sameDestination,
-  upsertIdentity,
-  upsertLinkedIdentity,
-  deleteProviderIdentityForSlackUser,
-  resolveRootConversationId,
-  parseSessionSource,
-  bindProviderConversation,
-  locationFromRow,
-  withConversationMutationLock,
-  sanitizePostgresJson,
-  withConversationEventLock,
-  createSqlConversationEventStore,
-  getSqlExecutor,
-  getDb,
-  getConversationStore,
-  getConversationEventStore,
-  getConversationMessageSearchStore,
-  closeDb
-};