@sentry/junior 0.75.0 → 0.76.0

package/dist/{chunk-UJ7OTHPO.js → chunk-R6Z5XWY3.js}

@@ -1,30 +1,25 @@
 import {
-  parseDestination,
-  sameDestination
-} from "./chunk-WBZ4M5N5.js";
-import {
-  juniorConversations,
-  juniorDestinations,
-  juniorIdentities
-} from "./chunk-D7NFH5GD.js";
+  JUNIOR_THREAD_STATE_TTL_MS
+} from "./chunk-Z4CIQ3EB.js";
 import {
   getDefaultRedisStateAdapterFor,
   getStateAdapter
-} from "./chunk-ZNNTSPNF.js";
+} from "./chunk-Y5OFBCBZ.js";
+import {
+  parseDestination,
+  sameDestination
+} from "./chunk-Q6XFTRV5.js";
 import {
   getChatConfig
-} from "./chunk-FCZO7LAR.js";
+} from "./chunk-T77LUIX3.js";
 import {
   parseStoredSlackRequester
-} from "./chunk-EIYL7I4S.js";
+} from "./chunk-VALUBQ7R.js";
 import {
   isRecord,
   toOptionalNumber,
   toOptionalString
-} from "./chunk-OK4KKR7B.js";
-
-// src/chat/state/ttl.ts
-var JUNIOR_THREAD_STATE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+} from "./chunk-EJN6G5A2.js";
 
 // src/chat/task-execution/state.ts
 import { randomUUID } from "crypto";
@@ -1058,666 +1053,14 @@ async function listConversationsByActivity(args = {}) {
   return conversations;
 }
 
-// src/chat/conversations/state.ts
-function createStateConversationStore(state) {
-  return {
-    get: (args) => getConversation({ ...args, state }),
-    recordActivity: (args) => recordConversationActivity({ ...args, state }),
-    recordExecution: async () => {
-    },
-    listByActivity: (args) => listConversationsByActivity({ ...args, state })
-  };
-}
-
-// src/chat/conversations/sql/store.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { asc, desc, eq, sql } from "drizzle-orm";
-
-// src/chat/conversations/sql/migrations.ts
-import { createHash } from "crypto";
-import { z } from "zod";
-var MIGRATION_LOCK_NAME = "junior_conversation_schema";
-var migrationRecordSchema = z.object({
-  id: z.string().min(1),
-  checksum: z.string().min(1)
-}).strict();
-function checksumStatements(statements) {
-  const hash = createHash("sha256");
-  for (const statement of statements) {
-    hash.update(statement);
-    hash.update("\0");
-  }
-  return hash.digest("hex");
-}
-function defineMigration(id, statements) {
-  return {
-    id,
-    checksum: checksumStatements(statements),
-    statements
-  };
-}
-var createMigrationTable = `
-CREATE TABLE IF NOT EXISTS junior_schema_migrations (
-  id TEXT PRIMARY KEY,
-  checksum TEXT NOT NULL,
-  applied_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
-)
-`;
-var coreMetadataStatements = [
-  `
-CREATE TABLE IF NOT EXISTS junior_identities (
-  id TEXT PRIMARY KEY,
-  kind TEXT NOT NULL,
-  provider TEXT NOT NULL,
-  provider_tenant_id TEXT NOT NULL DEFAULT '',
-  provider_subject_id TEXT NOT NULL,
-  display_name TEXT,
-  handle TEXT,
-  email TEXT,
-  avatar_url TEXT,
-  metadata_json JSONB,
-  created_at TIMESTAMPTZ NOT NULL,
-  updated_at TIMESTAMPTZ NOT NULL
-)
-`,
-  `
-CREATE UNIQUE INDEX IF NOT EXISTS junior_identities_provider_subject_uidx
-  ON junior_identities (provider, provider_tenant_id, provider_subject_id)
-`,
-  `
-CREATE INDEX IF NOT EXISTS junior_identities_kind_provider_idx
-  ON junior_identities (kind, provider)
-`,
-  `
-CREATE TABLE IF NOT EXISTS junior_destinations (
-  id TEXT PRIMARY KEY,
-  provider TEXT NOT NULL,
-  provider_tenant_id TEXT NOT NULL DEFAULT '',
-  provider_destination_id TEXT NOT NULL,
-  kind TEXT NOT NULL,
-  parent_destination_id TEXT,
-  display_name TEXT,
-  visibility TEXT NOT NULL DEFAULT 'unknown',
-  metadata_json JSONB,
-  created_at TIMESTAMPTZ NOT NULL,
-  updated_at TIMESTAMPTZ NOT NULL
-)
-`,
-  `
-CREATE UNIQUE INDEX IF NOT EXISTS junior_destinations_provider_destination_uidx
-  ON junior_destinations (provider, provider_tenant_id, provider_destination_id)
-`,
-  `
-CREATE INDEX IF NOT EXISTS junior_destinations_provider_kind_idx
-  ON junior_destinations (provider, kind)
-`,
-  `
-CREATE TABLE IF NOT EXISTS junior_conversations (
-  conversation_id TEXT PRIMARY KEY,
-  schema_version INTEGER NOT NULL DEFAULT 1,
-  source TEXT,
-  origin_type TEXT,
-  origin_id TEXT,
-  origin_run_id TEXT,
-  destination_id TEXT REFERENCES junior_destinations (id),
-  destination_json JSONB,
-  actor_identity_id TEXT REFERENCES junior_identities (id),
-  requester_identity_id TEXT REFERENCES junior_identities (id),
-  creator_identity_id TEXT REFERENCES junior_identities (id),
-  credential_subject_identity_id TEXT REFERENCES junior_identities (id),
-  requester_json JSONB,
-  channel_name TEXT,
-  title TEXT,
-  created_at TIMESTAMPTZ NOT NULL,
-  last_activity_at TIMESTAMPTZ NOT NULL,
-  updated_at TIMESTAMPTZ NOT NULL,
-  execution_updated_at TIMESTAMPTZ,
-  execution_status TEXT NOT NULL,
-  run_id TEXT,
-  last_checkpoint_at TIMESTAMPTZ,
-  last_enqueued_at TIMESTAMPTZ
-)
-`,
-  `
-CREATE INDEX IF NOT EXISTS junior_conversations_last_activity_idx
-  ON junior_conversations (last_activity_at DESC, conversation_id)
-`,
-  `
-CREATE INDEX IF NOT EXISTS junior_conversations_active_idx
-  ON junior_conversations (coalesce(execution_updated_at, updated_at) ASC, conversation_id)
-  WHERE execution_status <> 'idle'
-`,
-  `
-CREATE INDEX IF NOT EXISTS junior_conversations_destination_activity_idx
-  ON junior_conversations (destination_id, last_activity_at DESC)
-`,
-  `
-CREATE INDEX IF NOT EXISTS junior_conversations_actor_activity_idx
-  ON junior_conversations (actor_identity_id, last_activity_at DESC)
-`,
-  `
-CREATE INDEX IF NOT EXISTS junior_conversations_requester_activity_idx
-  ON junior_conversations (requester_identity_id, last_activity_at DESC)
-`,
-  `
-CREATE INDEX IF NOT EXISTS junior_conversations_origin_idx
-  ON junior_conversations (origin_type, origin_id, last_activity_at DESC)
-`
-];
-var migrations = [
-  defineMigration("0001_conversation_core", coreMetadataStatements)
-];
-function parseStoredMigrationRecord(value) {
-  return migrationRecordSchema.parse(value);
-}
-async function listAppliedMigrations(executor) {
-  const rows = await executor.query(
-    "SELECT id, checksum FROM junior_schema_migrations ORDER BY id ASC"
-  );
-  const records = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const record = parseStoredMigrationRecord(row);
-    records.set(record.id, record);
-  }
-  return records;
-}
-async function applyMigration(executor, migration) {
-  await executor.transaction(async () => {
-    for (const statement of migration.statements) {
-      await executor.execute(statement);
-    }
-    await executor.execute(
-      "INSERT INTO junior_schema_migrations (id, checksum) VALUES ($1, $2)",
-      [migration.id, migration.checksum]
-    );
-  });
-}
-async function migrateSchema(executor, migrationList = migrations) {
-  await executor.withLock(MIGRATION_LOCK_NAME, async () => {
-    await executor.execute(createMigrationTable);
-    const applied = await listAppliedMigrations(executor);
-    for (const migration of migrationList) {
-      const existing = applied.get(migration.id);
-      if (existing) {
-        if (existing.checksum !== migration.checksum) {
-          throw new Error(
-            `Conversation migration ${migration.id} checksum changed`
-          );
-        }
-        continue;
-      }
-      await applyMigration(executor, migration);
-    }
-  });
-}
-
-// src/chat/conversations/sql/store.ts
-var CONVERSATION_MUTATION_LOCK_PREFIX = "junior_conversation";
-function now2() {
-  return Date.now();
-}
-function dateFromMs(ms) {
-  return new Date(ms);
-}
-function tenantId(value) {
-  return value ?? "";
-}
-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 sourceFromValue(value) {
-  if (value === "api" || value === "internal" || value === "local" || value === "plugin" || value === "scheduler" || value === "slack") {
-    return value;
-  }
-  return void 0;
-}
-function identityFromRequester(requester) {
-  if (!requester?.slackUserId) {
-    return void 0;
-  }
-  return {
-    kind: "user",
-    provider: "slack",
-    providerTenantId: requester.teamId,
-    providerSubjectId: requester.slackUserId,
-    ...requester.fullName ? { displayName: requester.fullName } : {},
-    ...requester.slackUserName ? { handle: requester.slackUserName } : {},
-    ...requester.email ? { email: requester.email } : {},
-    metadata: { platform: "slack" }
-  };
-}
-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"
-    };
-  }
-  return void 0;
-}
-function actorIdentityForConversation(conversation) {
-  return identityFromRequester(conversation.requester) ?? systemIdentityFromSource(conversation.source);
-}
-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";
-    const visibility = channelId.startsWith("D") ? "direct" : channelId.startsWith("G") ? "private" : "public";
-    return {
-      kind: channelKind,
-      provider: "slack",
-      providerTenantId: destination.teamId,
-      providerDestinationId: channelId,
-      visibility,
-      ...args.channelName ? { displayName: args.channelName } : {},
-      metadata: { platform: "slack" }
-    };
-  }
-  return {
-    kind: "local_conversation",
-    provider: "local",
-    providerTenantId: localWorkspaceFromConversationId(destination.conversationId) ?? localWorkspaceFromConversationId(args.conversationId ?? ""),
-    providerDestinationId: destination.conversationId,
-    visibility: "direct",
-    metadata: { platform: "local" }
-  };
-}
-function executionStatusFromValue(value) {
-  if (value === "awaiting_resume" || value === "idle" || value === "pending" || value === "running") {
-    return value;
-  }
-  throw new Error("Conversation record execution status is invalid");
-}
-function conversationFromRow(row) {
-  if (row.schemaVersion !== 1) {
-    throw new Error("Conversation record schema version is invalid");
-  }
-  const destination = row.destination === void 0 || row.destination === null ? void 0 : parseDestination(row.destination);
-  const requester = parseStoredSlackRequester(row.requester);
-  if (row.destination !== void 0 && row.destination !== null && !destination) {
-    throw new Error("Conversation record destination is invalid");
-  }
-  if (row.requester !== void 0 && row.requester !== null && !requester) {
-    throw new Error("Conversation record requester 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 execution = {
-    status: executionStatusFromValue(row.executionStatus),
-    lastCheckpointAtMs: msFromDate(row.lastCheckpointAt),
-    lastEnqueuedAtMs: msFromDate(row.lastEnqueuedAt),
-    ...row.runId ? { runId: row.runId } : {},
-    updatedAtMs: msFromDate(row.executionUpdatedAt) ?? requiredMsFromDate(row.updatedAt)
-  };
-  return {
-    schemaVersion: 1,
-    conversationId: row.conversationId,
-    createdAtMs: requiredMsFromDate(row.createdAt),
-    lastActivityAtMs: requiredMsFromDate(row.lastActivityAt),
-    updatedAtMs: requiredMsFromDate(row.updatedAt),
-    execution,
-    ...destination ? { destination } : {},
-    ...requester ? { requester } : {},
-    ...row.channelName ? { channelName: row.channelName } : {},
-    ...source ? { source } : {},
-    ...row.title ? { title: row.title } : {}
-  };
-}
-function emptyConversation2(args) {
-  return {
-    schemaVersion: 1,
-    conversationId: args.conversationId,
-    createdAtMs: args.nowMs,
-    lastActivityAtMs: args.nowMs,
-    updatedAtMs: args.nowMs,
-    ...args.destination ? { destination: args.destination } : {},
-    ...args.source ? { source: args.source } : {},
-    execution: {
-      status: "idle",
-      updatedAtMs: args.nowMs
-    }
-  };
-}
-function assertSameConversationDestination2(args) {
-  if (!args.current || sameDestination(args.current, args.next)) {
-    return;
-  }
-  throw new Error(
-    `Conversation destination changed for ${args.conversationId}`
-  );
-}
-var SqlStore = class {
-  constructor(executor, migrationExecutor) {
-    this.executor = executor;
-    this.migrationExecutor = migrationExecutor;
-  }
-  executor;
-  migrationExecutor;
-  schemaReady;
-  /** Apply SQL schema migrations before runtime uses this store. */
-  async migrate() {
-    if (!this.schemaReady) {
-      this.schemaReady = migrateSchema(this.migrationExecutor);
-    }
-    const schemaReady = this.schemaReady;
-    try {
-      await schemaReady;
-    } catch (error) {
-      if (this.schemaReady === schemaReady) {
-        this.schemaReady = void 0;
-      }
-      throw error;
-    }
-  }
-  async get(args) {
-    const row = await this.readConversationRow(args.conversationId);
-    if (!row) {
-      return void 0;
-    }
-    return conversationFromRow(row);
-  }
-  async recordActivity(args) {
-    const nowMs = args.nowMs ?? now2();
-    const activityAtMs = args.activityAtMs ?? nowMs;
-    await this.withConversationMutation(args.conversationId, async () => {
-      const existing = await this.get({
-        conversationId: args.conversationId
-      });
-      if (existing && args.destination) {
-        assertSameConversationDestination2({
-          conversationId: args.conversationId,
-          current: existing.destination,
-          next: args.destination
-        });
-      }
-      const current = existing ?? emptyConversation2({
-        conversationId: args.conversationId,
-        destination: args.destination,
-        nowMs,
-        source: args.source
-      });
-      await this.upsertConversation({
-        conversation: {
-          ...current,
-          destination: current.destination ?? args.destination,
-          source: current.source ?? args.source,
-          channelName: current.channelName ?? args.channelName,
-          requester: current.requester ?? args.requester,
-          title: current.title ?? args.title,
-          lastActivityAtMs: Math.max(current.lastActivityAtMs, activityAtMs),
-          updatedAtMs: nowMs,
-          execution: {
-            ...current.execution,
-            updatedAtMs: current.execution.updatedAtMs ?? nowMs
-          }
-        }
-      });
-    });
-  }
-  async recordExecution(args) {
-    await this.withConversationMutation(args.conversationId, async () => {
-      await this.upsertConversation({
-        conversation: {
-          schemaVersion: 1,
-          conversationId: args.conversationId,
-          createdAtMs: args.createdAtMs,
-          lastActivityAtMs: args.lastActivityAtMs,
-          updatedAtMs: args.updatedAtMs,
-          ...args.channelName ? { channelName: args.channelName } : {},
-          ...args.destination ? { destination: args.destination } : {},
-          ...args.requester ? { requester: args.requester } : {},
-          ...args.source ? { source: args.source } : {},
-          ...args.title ? { title: args.title } : {},
-          execution: args.execution
-        }
-      });
-    });
-  }
-  /** Copy one conversation record into SQL during backfill. */
-  async backfillConversation(conversation) {
-    await this.withConversationMutation(
-      conversation.conversationId,
-      async () => {
-        const existing = await this.get({
-          conversationId: conversation.conversationId
-        });
-        const sourceExecutionAtMs = conversation.execution.updatedAtMs ?? conversation.updatedAtMs;
-        const existingExecutionAtMs = existing === void 0 ? void 0 : existing.execution.updatedAtMs ?? existing.updatedAtMs;
-        const refreshExecutionFromSource = existingExecutionAtMs === void 0 || sourceExecutionAtMs >= existingExecutionAtMs;
-        const mergedConversation = existing ? {
-          ...conversation,
-          channelName: existing.channelName ?? conversation.channelName,
-          createdAtMs: Math.min(
-            existing.createdAtMs,
-            conversation.createdAtMs
-          ),
-          destination: existing.destination ?? conversation.destination,
-          lastActivityAtMs: Math.max(
-            existing.lastActivityAtMs,
-            conversation.lastActivityAtMs
-          ),
-          requester: existing.requester ?? conversation.requester,
-          source: existing.source ?? conversation.source,
-          title: existing.title ?? conversation.title,
-          updatedAtMs: Math.max(
-            existing.updatedAtMs,
-            conversation.updatedAtMs
-          ),
-          execution: refreshExecutionFromSource ? conversation.execution : existing.execution
-        } : conversation;
-        await this.upsertConversation({ conversation: mergedConversation });
-      }
-    );
-  }
-  async listByActivity(args = {}) {
-    const rows = await this.executor.db().select().from(juniorConversations).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;
-  }
-  /** Serialize all durable mutations for one conversation inside a SQL transaction. */
-  async withConversationMutation(conversationId, callback) {
-    return await this.executor.withLock(
-      `${CONVERSATION_MUTATION_LOCK_PREFIX}:${conversationId}`,
-      async () => await this.executor.transaction(callback)
-    );
-  }
-  async readConversationRow(conversationId) {
-    const rows = await this.executor.db().select().from(juniorConversations).where(eq(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 = sql`coalesce(excluded.execution_updated_at, excluded.updated_at)`;
-    const currentExecutionVersion = sql`coalesce(${juniorConversations.executionUpdatedAt}, ${juniorConversations.updatedAt})`;
-    const incomingExecutionIsFresh = sql`${incomingExecutionVersion} >= ${currentExecutionVersion}`;
-    const destinationId = await this.upsertDestination(
-      destinationUpsertFromDestination({
-        channelName: conversation.channelName,
-        conversationId: conversation.conversationId,
-        destination: conversation.destination
-      }),
-      conversation.updatedAtMs
-    );
-    const requesterIdentityId = await this.upsertIdentity(
-      identityFromRequester(conversation.requester),
-      conversation.updatedAtMs
-    );
-    const actorIdentityId = await this.upsertIdentity(
-      actorIdentityForConversation(conversation),
-      conversation.updatedAtMs
-    );
-    await this.executor.db().insert(juniorConversations).values({
-      conversationId: conversation.conversationId,
-      schemaVersion: 1,
-      source: conversation.source ?? null,
-      originType: originTypeFromSource(conversation.source) ?? null,
-      originId: null,
-      originRunId: null,
-      destinationId: destinationId ?? null,
-      destination: conversation.destination ?? null,
-      actorIdentityId: actorIdentityId ?? null,
-      requesterIdentityId: requesterIdentityId ?? null,
-      creatorIdentityId: null,
-      credentialSubjectIdentityId: null,
-      requester: conversation.requester ?? null,
-      channelName: conversation.channelName ?? null,
-      title: conversation.title ?? null,
-      createdAt: dateFromMs(conversation.createdAtMs),
-      lastActivityAt: dateFromMs(conversation.lastActivityAtMs),
-      updatedAt: dateFromMs(conversation.updatedAtMs),
-      executionUpdatedAt: conversation.execution.updatedAtMs === void 0 ? null : dateFromMs(conversation.execution.updatedAtMs),
-      executionStatus: conversation.execution.status,
-      runId: conversation.execution.runId ?? null,
-      lastCheckpointAt: conversation.execution.lastCheckpointAtMs === void 0 ? null : dateFromMs(conversation.execution.lastCheckpointAtMs),
-      lastEnqueuedAt: conversation.execution.lastEnqueuedAtMs === void 0 ? null : dateFromMs(conversation.execution.lastEnqueuedAtMs)
-    }).onConflictDoUpdate({
-      target: juniorConversations.conversationId,
-      set: {
-        source: sql`coalesce(excluded.source, ${juniorConversations.source})`,
-        originType: sql`coalesce(excluded.origin_type, ${juniorConversations.originType})`,
-        originId: sql`coalesce(excluded.origin_id, ${juniorConversations.originId})`,
-        originRunId: sql`coalesce(excluded.origin_run_id, ${juniorConversations.originRunId})`,
-        destinationId: sql`coalesce(excluded.destination_id, ${juniorConversations.destinationId})`,
-        destination: sql`coalesce(excluded.destination_json, ${juniorConversations.destination})`,
-        actorIdentityId: sql`coalesce(excluded.actor_identity_id, ${juniorConversations.actorIdentityId})`,
-        requesterIdentityId: sql`coalesce(excluded.requester_identity_id, ${juniorConversations.requesterIdentityId})`,
-        creatorIdentityId: sql`coalesce(excluded.creator_identity_id, ${juniorConversations.creatorIdentityId})`,
-        credentialSubjectIdentityId: sql`coalesce(excluded.credential_subject_identity_id, ${juniorConversations.credentialSubjectIdentityId})`,
-        requester: sql`coalesce(excluded.requester_json, ${juniorConversations.requester})`,
-        channelName: sql`coalesce(excluded.channel_name, ${juniorConversations.channelName})`,
-        title: sql`coalesce(excluded.title, ${juniorConversations.title})`,
-        createdAt: sql`least(${juniorConversations.createdAt}, excluded.created_at)`,
-        lastActivityAt: sql`greatest(${juniorConversations.lastActivityAt}, excluded.last_activity_at)`,
-        updatedAt: sql`greatest(${juniorConversations.updatedAt}, excluded.updated_at)`,
-        executionUpdatedAt: sql`case when ${incomingExecutionIsFresh} then excluded.execution_updated_at else ${juniorConversations.executionUpdatedAt} end`,
-        executionStatus: sql`case when ${incomingExecutionIsFresh} then excluded.execution_status else ${juniorConversations.executionStatus} end`,
-        runId: sql`case when ${incomingExecutionIsFresh} then excluded.run_id else ${juniorConversations.runId} end`,
-        lastCheckpointAt: sql`case when ${incomingExecutionIsFresh} then excluded.last_checkpoint_at else ${juniorConversations.lastCheckpointAt} end`,
-        lastEnqueuedAt: sql`case when ${incomingExecutionIsFresh} then excluded.last_enqueued_at else ${juniorConversations.lastEnqueuedAt} end`
-      }
-    });
-  }
-  async upsertIdentity(identity, nowMs) {
-    if (!identity) {
-      return void 0;
-    }
-    const rows = await this.executor.db().insert(juniorIdentities).values({
-      id: randomUUID2(),
-      kind: identity.kind,
-      provider: identity.provider,
-      providerTenantId: tenantId(identity.providerTenantId),
-      providerSubjectId: identity.providerSubjectId,
-      displayName: identity.displayName ?? null,
-      handle: identity.handle ?? null,
-      email: identity.email ?? null,
-      avatarUrl: null,
-      metadata: identity.metadata ?? null,
-      createdAt: dateFromMs(nowMs),
-      updatedAt: dateFromMs(nowMs)
-    }).onConflictDoUpdate({
-      target: [
-        juniorIdentities.provider,
-        juniorIdentities.providerTenantId,
-        juniorIdentities.providerSubjectId
-      ],
-      set: {
-        kind: sql`excluded.kind`,
-        displayName: sql`coalesce(excluded.display_name, ${juniorIdentities.displayName})`,
-        handle: sql`coalesce(excluded.handle, ${juniorIdentities.handle})`,
-        email: sql`coalesce(excluded.email, ${juniorIdentities.email})`,
-        avatarUrl: sql`coalesce(excluded.avatar_url, ${juniorIdentities.avatarUrl})`,
-        metadata: sql`coalesce(excluded.metadata_json, ${juniorIdentities.metadata})`,
-        updatedAt: sql`excluded.updated_at`
-      }
-    }).returning({ id: juniorIdentities.id });
-    return rows[0]?.id;
-  }
-  async upsertDestination(destination, nowMs) {
-    if (!destination) {
-      return void 0;
-    }
-    const rows = await this.executor.db().insert(juniorDestinations).values({
-      id: randomUUID2(),
-      provider: destination.provider,
-      providerTenantId: tenantId(destination.providerTenantId),
-      providerDestinationId: destination.providerDestinationId,
-      kind: destination.kind,
-      parentDestinationId: null,
-      displayName: destination.displayName ?? null,
-      visibility: destination.visibility,
-      metadata: destination.metadata ?? null,
-      createdAt: dateFromMs(nowMs),
-      updatedAt: dateFromMs(nowMs)
-    }).onConflictDoUpdate({
-      target: [
-        juniorDestinations.provider,
-        juniorDestinations.providerTenantId,
-        juniorDestinations.providerDestinationId
-      ],
-      set: {
-        kind: sql`excluded.kind`,
-        displayName: sql`coalesce(excluded.display_name, ${juniorDestinations.displayName})`,
-        visibility: sql`excluded.visibility`,
-        metadata: sql`coalesce(excluded.metadata_json, ${juniorDestinations.metadata})`,
-        updatedAt: sql`excluded.updated_at`
-      }
-    }).returning({ id: juniorDestinations.id });
-    return rows[0]?.id;
-  }
-};
-function createSqlStore(executor) {
-  return new SqlStore(executor, executor);
-}
-
 export {
-  JUNIOR_THREAD_STATE_TTL_MS,
   CONVERSATION_WORK_CHECK_IN_INTERVAL_MS,
   CONVERSATION_WORK_STALE_ENQUEUE_MS,
   getConversation,
   getConversationWorkState,
   appendInboundMessage,
   requestConversationWork,
+  recordConversationActivity,
   markConversationWorkEnqueued,
   startConversationWork,
   checkInConversationWork,
@@ -1729,6 +1072,5 @@ export {
   clearExpiredConversationLease,
   removeActiveConversation,
   listActiveConversationIds,
-  createStateConversationStore,
-  createSqlStore
+  listConversationsByActivity
 };