@sentry/junior 0.73.0 → 0.74.0

package/dist/chunk-JL2SLRAT.js

@@ -0,0 +1,1970 @@
+import {
+  parseDestination,
+  sameDestination
+} from "./chunk-YRDS7VKO.js";
+import {
+  getDefaultRedisStateAdapterFor,
+  getStateAdapter
+} from "./chunk-F6HWCPOC.js";
+import {
+  getChatConfig
+} from "./chunk-GM7HTXYC.js";
+import {
+  parseStoredSlackRequester
+} from "./chunk-CYUI7JU5.js";
+import {
+  isRecord,
+  toOptionalNumber,
+  toOptionalString
+} from "./chunk-3BYAPS6B.js";
+
+// src/chat/state/ttl.ts
+var JUNIOR_THREAD_STATE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+
+// src/chat/sql/neon.ts
+import { AsyncLocalStorage } from "async_hooks";
+import {
+  Pool
+} from "@neondatabase/serverless";
+import { drizzle } from "drizzle-orm/neon-serverless";
+
+// src/chat/conversations/sql/schema/conversations.ts
+import { sql } from "drizzle-orm";
+import { index as index3, integer, jsonb as jsonb3, pgTable as pgTable3, text as text3 } from "drizzle-orm/pg-core";
+
+// src/chat/conversations/sql/schema/destinations.ts
+import { index, jsonb, pgTable, text, uniqueIndex } from "drizzle-orm/pg-core";
+
+// src/chat/conversations/sql/schema/timestamps.ts
+import { timestamp } from "drizzle-orm/pg-core";
+var timestamptz = (name) => timestamp(name, { withTimezone: true });
+
+// src/chat/conversations/sql/schema/destinations.ts
+var juniorDestinations = pgTable(
+  "junior_destinations",
+  {
+    id: text("id").primaryKey(),
+    provider: text("provider").notNull(),
+    providerTenantId: text("provider_tenant_id").notNull().default(""),
+    providerDestinationId: text("provider_destination_id").notNull(),
+    kind: text("kind").$type().notNull(),
+    parentDestinationId: text("parent_destination_id"),
+    displayName: text("display_name"),
+    visibility: text("visibility").$type().notNull().default("unknown"),
+    metadata: jsonb("metadata_json"),
+    createdAt: timestamptz("created_at").notNull(),
+    updatedAt: timestamptz("updated_at").notNull()
+  },
+  (table) => [
+    uniqueIndex("junior_destinations_provider_destination_uidx").on(
+      table.provider,
+      table.providerTenantId,
+      table.providerDestinationId
+    ),
+    index("junior_destinations_provider_kind_idx").on(
+      table.provider,
+      table.kind
+    )
+  ]
+);
+
+// src/chat/conversations/sql/schema/identities.ts
+import { index as index2, jsonb as jsonb2, pgTable as pgTable2, text as text2, uniqueIndex as uniqueIndex2 } from "drizzle-orm/pg-core";
+var juniorIdentities = pgTable2(
+  "junior_identities",
+  {
+    id: text2("id").primaryKey(),
+    kind: text2("kind").$type().notNull(),
+    provider: text2("provider").notNull(),
+    providerTenantId: text2("provider_tenant_id").notNull().default(""),
+    providerSubjectId: text2("provider_subject_id").notNull(),
+    displayName: text2("display_name"),
+    handle: text2("handle"),
+    email: text2("email"),
+    avatarUrl: text2("avatar_url"),
+    metadata: jsonb2("metadata_json"),
+    createdAt: timestamptz("created_at").notNull(),
+    updatedAt: timestamptz("updated_at").notNull()
+  },
+  (table) => [
+    uniqueIndex2("junior_identities_provider_subject_uidx").on(
+      table.provider,
+      table.providerTenantId,
+      table.providerSubjectId
+    ),
+    index2("junior_identities_kind_provider_idx").on(table.kind, table.provider)
+  ]
+);
+
+// src/chat/conversations/sql/schema/conversations.ts
+var juniorConversations = pgTable3(
+  "junior_conversations",
+  {
+    conversationId: text3("conversation_id").primaryKey(),
+    schemaVersion: integer("schema_version").notNull().default(1),
+    source: text3("source").$type(),
+    originType: text3("origin_type"),
+    originId: text3("origin_id"),
+    originRunId: text3("origin_run_id"),
+    destinationId: text3("destination_id").references(
+      () => juniorDestinations.id
+    ),
+    destination: jsonb3("destination_json").$type(),
+    actorIdentityId: text3("actor_identity_id").references(
+      () => juniorIdentities.id
+    ),
+    requesterIdentityId: text3("requester_identity_id").references(
+      () => juniorIdentities.id
+    ),
+    creatorIdentityId: text3("creator_identity_id").references(
+      () => juniorIdentities.id
+    ),
+    credentialSubjectIdentityId: text3(
+      "credential_subject_identity_id"
+    ).references(() => juniorIdentities.id),
+    requester: jsonb3("requester_json").$type(),
+    channelName: text3("channel_name"),
+    title: text3("title"),
+    createdAt: timestamptz("created_at").notNull(),
+    lastActivityAt: timestamptz("last_activity_at").notNull(),
+    updatedAt: timestamptz("updated_at").notNull(),
+    executionUpdatedAt: timestamptz("execution_updated_at"),
+    executionStatus: text3("execution_status").$type().notNull(),
+    runId: text3("run_id"),
+    lastCheckpointAt: timestamptz("last_checkpoint_at"),
+    lastEnqueuedAt: timestamptz("last_enqueued_at")
+  },
+  (table) => [
+    index3("junior_conversations_last_activity_idx").on(
+      table.lastActivityAt.desc(),
+      table.conversationId
+    ),
+    index3("junior_conversations_active_idx").using(
+      "btree",
+      sql`coalesce(${table.executionUpdatedAt}, ${table.updatedAt})`,
+      table.conversationId
+    ).where(sql`${table.executionStatus} <> 'idle'`),
+    index3("junior_conversations_destination_activity_idx").on(
+      table.destinationId,
+      table.lastActivityAt.desc()
+    ),
+    index3("junior_conversations_actor_activity_idx").on(
+      table.actorIdentityId,
+      table.lastActivityAt.desc()
+    ),
+    index3("junior_conversations_requester_activity_idx").on(
+      table.requesterIdentityId,
+      table.lastActivityAt.desc()
+    ),
+    index3("junior_conversations_origin_idx").on(
+      table.originType,
+      table.originId,
+      table.lastActivityAt.desc()
+    )
+  ]
+);
+
+// src/chat/conversations/sql/schema/migrations.ts
+import { pgTable as pgTable4, text as text4 } from "drizzle-orm/pg-core";
+var juniorSchemaMigrations = pgTable4("junior_schema_migrations", {
+  id: text4("id").primaryKey(),
+  checksum: text4("checksum").notNull(),
+  appliedAt: timestamptz("applied_at").notNull().defaultNow()
+});
+
+// src/chat/conversations/sql/schema.ts
+var schema = {
+  juniorConversations,
+  juniorDestinations,
+  juniorIdentities,
+  juniorSchemaMigrations
+};
+
+// src/chat/sql/schema.ts
+var juniorSqlSchema = {
+  ...schema
+};
+
+// src/chat/sql/neon.ts
+var NeonExecutor = class {
+  constructor(pool) {
+    this.pool = pool;
+  }
+  pool;
+  transactionClient = new AsyncLocalStorage();
+  db() {
+    return drizzle(this.queryClient(), {
+      schema: juniorSqlSchema
+    });
+  }
+  async execute(statement, params = []) {
+    await this.queryClient().query(statement, [...params]);
+  }
+  async query(statement, params = []) {
+    const result = await this.queryClient().query(statement, [
+      ...params
+    ]);
+    return result.rows;
+  }
+  async transaction(callback) {
+    const existingClient = this.transactionClient.getStore();
+    if (existingClient) {
+      return await callback();
+    }
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const result = await this.transactionClient.run(client, callback);
+      await client.query("COMMIT");
+      return result;
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async withLock(lockName, callback) {
+    if (!lockName) {
+      throw new Error("SQL lock name is required");
+    }
+    const existingClient = this.transactionClient.getStore();
+    if (existingClient) {
+      await existingClient.query("SELECT pg_advisory_xact_lock(hashtext($1))", [
+        lockName
+      ]);
+      return await callback();
+    }
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      return await this.transactionClient.run(client, async () => {
+        try {
+          await client.query("SELECT pg_advisory_xact_lock(hashtext($1))", [
+            lockName
+          ]);
+          const result = await callback();
+          await client.query("COMMIT");
+          return result;
+        } catch (error) {
+          await client.query("ROLLBACK");
+          throw error;
+        }
+      });
+    } finally {
+      client.release();
+    }
+  }
+  async close() {
+    await this.pool.end();
+  }
+  queryClient() {
+    return this.transactionClient.getStore() ?? this.pool;
+  }
+};
+function createNeonJuniorSqlExecutor(args) {
+  return new NeonExecutor(
+    new Pool({
+      connectionString: args.connectionString,
+      max: 3
+    })
+  );
+}
+
+// src/chat/task-execution/state.ts
+import { randomUUID } from "crypto";
+var CONVERSATION_PREFIX = "junior:conversation";
+var CONVERSATION_SCHEMA_VERSION = 1;
+var CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH = 1e4;
+var CONVERSATION_INDEX_LOCK_TTL_MS = 1e4;
+var CONVERSATION_INDEX_LOCK_WAIT_MS = 2e3;
+var CONVERSATION_INDEX_LOCK_RETRY_MS = 25;
+var CONVERSATION_MUTATION_LOCK_TTL_MS = 1e4;
+var CONVERSATION_MUTATION_WAIT_MS = 1e4;
+var CONVERSATION_MUTATION_RETRY_MS = 25;
+var InvalidConversationRecordError = class extends Error {
+  constructor(conversationId) {
+    super(`Conversation record is invalid for ${conversationId}`);
+    this.name = "InvalidConversationRecordError";
+  }
+};
+var CONVERSATION_BY_ACTIVITY_INDEX_KEY = `${CONVERSATION_PREFIX}:by-activity`;
+var CONVERSATION_ACTIVE_INDEX_KEY = `${CONVERSATION_PREFIX}:active`;
+var CONVERSATION_WORK_LEASE_TTL_MS = 9e4;
+var CONVERSATION_WORK_CHECK_IN_INTERVAL_MS = 15e3;
+var CONVERSATION_WORK_STALE_ENQUEUE_MS = 6e4;
+function conversationKey(conversationId) {
+  return `${CONVERSATION_PREFIX}:${conversationId}`;
+}
+function indexLockKey(indexKey) {
+  return `${indexKey}:lock`;
+}
+function mutationLockKey(conversationId) {
+  return `${CONVERSATION_PREFIX}:mutation:${conversationId}`;
+}
+function now() {
+  return Date.now();
+}
+function compareMessages(left, right) {
+  return left.createdAtMs - right.createdAtMs || left.receivedAtMs - right.receivedAtMs || left.inboundMessageId.localeCompare(right.inboundMessageId);
+}
+function compareIndexDescending(left, right) {
+  return right.score - left.score || right.conversationId.localeCompare(left.conversationId);
+}
+function compareIndexAscending(left, right) {
+  return left.score - right.score || left.conversationId.localeCompare(right.conversationId);
+}
+function uniqueStrings(values) {
+  return [...new Set(values)];
+}
+function normalizeSource(value) {
+  if (value === "api" || value === "internal" || value === "local" || value === "plugin" || value === "scheduler" || value === "slack") {
+    return value;
+  }
+  return void 0;
+}
+function normalizeExecutionStatus(value) {
+  if (value === "awaiting_resume" || value === "idle" || value === "pending" || value === "running") {
+    return value;
+  }
+  return void 0;
+}
+function normalizeMetadata(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  return value;
+}
+function normalizeInput(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const text5 = toOptionalString(value.text);
+  if (!text5) {
+    return void 0;
+  }
+  return {
+    text: text5,
+    authorId: toOptionalString(value.authorId),
+    attachments: Array.isArray(value.attachments) ? [...value.attachments] : void 0,
+    metadata: normalizeMetadata(value.metadata)
+  };
+}
+function normalizeMessage(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const conversationId = toOptionalString(value.conversationId);
+  const inboundMessageId = toOptionalString(value.inboundMessageId);
+  const source = normalizeSource(value.source);
+  const destination = parseDestination(value.destination);
+  const createdAtMs = toOptionalNumber(value.createdAtMs);
+  const receivedAtMs = toOptionalNumber(value.receivedAtMs);
+  const input = normalizeInput(value.input);
+  if (!conversationId || !destination || !inboundMessageId || !source || typeof createdAtMs !== "number" || typeof receivedAtMs !== "number" || !input) {
+    return void 0;
+  }
+  return {
+    conversationId,
+    destination,
+    inboundMessageId,
+    source,
+    createdAtMs,
+    receivedAtMs,
+    input,
+    injectedAtMs: toOptionalNumber(value.injectedAtMs)
+  };
+}
+function normalizeRequester(value) {
+  return parseStoredSlackRequester(value);
+}
+function normalizeLease(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const token = toOptionalString(value.token);
+  const acquiredAtMs = toOptionalNumber(value.acquiredAtMs);
+  const lastCheckInAtMs = toOptionalNumber(value.lastCheckInAtMs);
+  const expiresAtMs = toOptionalNumber(value.expiresAtMs);
+  if (!token || typeof acquiredAtMs !== "number" || typeof lastCheckInAtMs !== "number" || typeof expiresAtMs !== "number") {
+    return void 0;
+  }
+  return {
+    token,
+    acquiredAtMs,
+    lastCheckInAtMs,
+    expiresAtMs
+  };
+}
+function normalizeExecution(conversationId, value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const status = normalizeExecutionStatus(value.status);
+  if (!status) {
+    return void 0;
+  }
+  const pendingMessages2 = Array.isArray(value.pendingMessages) ? value.pendingMessages.map(normalizeMessage).filter((message) => Boolean(message)).filter((message) => message.conversationId === conversationId).filter((message) => message.injectedAtMs === void 0).sort(compareMessages) : [];
+  const inboundMessageIds = Array.isArray(value.inboundMessageIds) ? uniqueStrings(
+    value.inboundMessageIds.map((id) => typeof id === "string" ? id : void 0).filter((id) => Boolean(id))
+  ) : [];
+  const lease = normalizeLease(value.lease);
+  const normalizedStatus = status === "idle" && lease ? "running" : status === "idle" && pendingMessages2.length > 0 ? "pending" : status;
+  return {
+    status: normalizedStatus,
+    inboundMessageIds: uniqueStrings([
+      ...inboundMessageIds,
+      ...pendingMessages2.map((message) => message.inboundMessageId)
+    ]),
+    pendingCount: pendingMessages2.length,
+    pendingMessages: pendingMessages2,
+    lease,
+    lastCheckpointAtMs: toOptionalNumber(value.lastCheckpointAtMs),
+    lastEnqueuedAtMs: toOptionalNumber(value.lastEnqueuedAtMs),
+    runId: toOptionalString(value.runId),
+    updatedAtMs: toOptionalNumber(value.updatedAtMs)
+  };
+}
+function normalizeConversation(conversationId, value) {
+  if (!isRecord(value) || value.schemaVersion !== CONVERSATION_SCHEMA_VERSION) {
+    return void 0;
+  }
+  const storedConversationId = toOptionalString(value.conversationId);
+  const createdAtMs = toOptionalNumber(value.createdAtMs);
+  const lastActivityAtMs = toOptionalNumber(value.lastActivityAtMs);
+  const updatedAtMs = toOptionalNumber(value.updatedAtMs);
+  const execution = normalizeExecution(conversationId, value.execution);
+  const destination = value.destination === void 0 ? void 0 : parseDestination(value.destination);
+  if (storedConversationId !== conversationId || typeof createdAtMs !== "number" || typeof lastActivityAtMs !== "number" || typeof updatedAtMs !== "number" || !execution || value.destination !== void 0 && !destination) {
+    return void 0;
+  }
+  if (execution.pendingMessages.length > 0 && (!destination || execution.pendingMessages.some(
+    (message) => !sameDestination(message.destination, destination)
+  ))) {
+    return void 0;
+  }
+  return {
+    schemaVersion: CONVERSATION_SCHEMA_VERSION,
+    conversationId,
+    createdAtMs,
+    lastActivityAtMs,
+    updatedAtMs,
+    execution,
+    ...destination ? { destination } : {},
+    ...toOptionalString(value.title) ? { title: toOptionalString(value.title) } : {},
+    ...toOptionalString(value.channelName) ? { channelName: toOptionalString(value.channelName) } : {},
+    ...normalizeRequester(value.requester) ? { requester: normalizeRequester(value.requester) } : {},
+    ...normalizeSource(value.source) ? { source: normalizeSource(value.source) } : {}
+  };
+}
+function emptyConversation(args) {
+  return {
+    schemaVersion: CONVERSATION_SCHEMA_VERSION,
+    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",
+      inboundMessageIds: [],
+      pendingCount: 0,
+      pendingMessages: [],
+      updatedAtMs: args.nowMs
+    }
+  };
+}
+function isLeaseActive(lease, nowMs) {
+  return Boolean(lease && lease.expiresAtMs > nowMs);
+}
+function pendingMessages(conversation) {
+  return [...conversation.execution.pendingMessages].sort(compareMessages);
+}
+function hasRunnableWork(conversation) {
+  return conversation.execution.status !== "idle" || pendingMessages(conversation).length > 0;
+}
+function executionWithPendingMessages(execution, pending) {
+  const pendingMessages2 = [...pending].sort(compareMessages);
+  const status = execution.status === "idle" && execution.lease ? "running" : execution.status === "idle" && pendingMessages2.length > 0 ? "pending" : execution.status;
+  return {
+    ...execution,
+    status,
+    inboundMessageIds: uniqueStrings([
+      ...execution.inboundMessageIds,
+      ...pendingMessages2.map((message) => message.inboundMessageId)
+    ]),
+    pendingMessages: pendingMessages2,
+    pendingCount: pendingMessages2.length
+  };
+}
+function withExecutionUpdate(conversation, execution, nowMs) {
+  return {
+    ...conversation,
+    updatedAtMs: nowMs,
+    execution: {
+      ...executionWithPendingMessages(execution, execution.pendingMessages),
+      updatedAtMs: nowMs
+    }
+  };
+}
+async function getConnectedState(stateAdapter) {
+  const state = stateAdapter ?? getStateAdapter();
+  await state.connect();
+  return state;
+}
+async function sleep(ms) {
+  await new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    timer.unref?.();
+  });
+}
+async function withIndexLock(state, indexKey, callback) {
+  const startedAtMs = now();
+  let lock;
+  while (true) {
+    lock = await state.acquireLock(
+      indexLockKey(indexKey),
+      CONVERSATION_INDEX_LOCK_TTL_MS
+    );
+    if (lock) {
+      break;
+    }
+    if (now() - startedAtMs >= CONVERSATION_INDEX_LOCK_WAIT_MS) {
+      throw new Error(
+        `Could not acquire conversation index lock for ${indexKey}`
+      );
+    }
+    await sleep(CONVERSATION_INDEX_LOCK_RETRY_MS);
+  }
+  try {
+    return await callback();
+  } finally {
+    await state.releaseLock(lock);
+  }
+}
+function normalizeIndexEntry(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const conversationId = toOptionalString(value.conversationId);
+  const score = toOptionalNumber(value.score);
+  if (!conversationId || typeof score !== "number") {
+    return void 0;
+  }
+  return { conversationId, score };
+}
+function uniqueIndexEntries(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const entries = /* @__PURE__ */ new Map();
+  for (const item of value) {
+    const entry = normalizeIndexEntry(item);
+    if (!entry) {
+      continue;
+    }
+    const existing = entries.get(entry.conversationId);
+    if (!existing || entry.score > existing.score) {
+      entries.set(entry.conversationId, entry);
+    }
+  }
+  return [...entries.values()];
+}
+function retainedIndexEntries(indexKey, entries) {
+  if (indexKey === CONVERSATION_BY_ACTIVITY_INDEX_KEY) {
+    return entries.sort(compareIndexDescending).slice(0, CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH);
+  }
+  if (indexKey === CONVERSATION_ACTIVE_INDEX_KEY) {
+    return entries.sort(compareIndexAscending);
+  }
+  throw new Error(`Unknown conversation index ${indexKey}`);
+}
+function redisIndexKey(indexKey) {
+  const prefix = getChatConfig().state.keyPrefix;
+  return [...prefix ? [prefix] : [], indexKey].join(":");
+}
+function parseRedisIndexEntries(values) {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+  const entries = [];
+  for (let index4 = 0; index4 < values.length; index4 += 2) {
+    const conversationId = toOptionalString(values[index4]);
+    const score = typeof values[index4 + 1] === "number" ? values[index4 + 1] : Number(values[index4 + 1]);
+    if (!conversationId || !Number.isFinite(score)) {
+      continue;
+    }
+    entries.push({ conversationId, score });
+  }
+  return entries;
+}
+function redisConversationIndexStore(client) {
+  const upsertBoundedActivityScript = `
+    redis.call("ZADD", KEYS[1], ARGV[1], ARGV[2])
+    redis.call("PEXPIRE", KEYS[1], ARGV[3])
+    local extra = redis.call("ZCARD", KEYS[1]) - tonumber(ARGV[4])
+    if extra > 0 then
+      redis.call("ZREMRANGEBYRANK", KEYS[1], 0, extra - 1)
+    end
+    return 1
+  `;
+  return {
+    async list(args) {
+      const key = redisIndexKey(args.indexKey);
+      const limit = args.limit;
+      const offset = Math.max(0, args.offset ?? 0);
+      if (limit === 0) {
+        return [];
+      }
+      const values = args.scoreMax !== void 0 ? await client.sendCommand([
+        "ZRANGEBYSCORE",
+        key,
+        "-inf",
+        String(args.scoreMax),
+        "WITHSCORES",
+        ...limit !== void 0 || offset > 0 ? ["LIMIT", String(offset), String(limit ?? 1e9)] : []
+      ]) : await client.sendCommand([
+        args.order === "asc" ? "ZRANGE" : "ZREVRANGE",
+        key,
+        String(offset),
+        String(
+          limit === void 0 ? -1 : offset + Math.max(0, limit - 1)
+        ),
+        "WITHSCORES"
+      ]);
+      return parseRedisIndexEntries(values);
+    },
+    async remove(args) {
+      await client.sendCommand([
+        "ZREM",
+        redisIndexKey(args.indexKey),
+        args.conversationId
+      ]);
+    },
+    async upsert(args) {
+      const key = redisIndexKey(args.indexKey);
+      if (args.indexKey === CONVERSATION_BY_ACTIVITY_INDEX_KEY) {
+        await client.sendCommand([
+          "EVAL",
+          upsertBoundedActivityScript,
+          "1",
+          key,
+          String(args.score),
+          args.conversationId,
+          String(JUNIOR_THREAD_STATE_TTL_MS),
+          String(CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH)
+        ]);
+        return;
+      }
+      if (args.indexKey === CONVERSATION_ACTIVE_INDEX_KEY) {
+        await client.sendCommand([
+          "ZADD",
+          key,
+          String(args.score),
+          args.conversationId
+        ]);
+        await client.sendCommand([
+          "PEXPIRE",
+          key,
+          String(JUNIOR_THREAD_STATE_TTL_MS)
+        ]);
+        return;
+      }
+      throw new Error(`Unknown conversation index ${args.indexKey}`);
+    }
+  };
+}
+function emulatedConversationIndexStore(state) {
+  const readIndex = async (indexKey) => uniqueIndexEntries(await state.get(indexKey));
+  const writeIndex = async (indexKey, entries) => {
+    await state.set(indexKey, entries, JUNIOR_THREAD_STATE_TTL_MS);
+  };
+  return {
+    async list(args) {
+      const entries = (await readIndex(args.indexKey)).filter(
+        (entry) => args.scoreMax === void 0 ? true : entry.score <= args.scoreMax
+      ).sort(
+        args.order === "asc" ? compareIndexAscending : compareIndexDescending
+      );
+      const offset = Math.max(0, args.offset ?? 0);
+      return entries.slice(
+        offset,
+        args.limit === void 0 ? entries.length : offset + args.limit
+      );
+    },
+    async remove(args) {
+      await withIndexLock(state, args.indexKey, async () => {
+        const entries = await readIndex(args.indexKey);
+        const next = entries.filter(
+          (entry) => entry.conversationId !== args.conversationId
+        );
+        if (next.length === entries.length) {
+          return;
+        }
+        await writeIndex(args.indexKey, next);
+      });
+    },
+    async upsert(args) {
+      await withIndexLock(state, args.indexKey, async () => {
+        const entries = await readIndex(args.indexKey);
+        const withoutCurrent = entries.filter(
+          (entry) => entry.conversationId !== args.conversationId
+        );
+        const next = retainedIndexEntries(args.indexKey, [
+          ...withoutCurrent,
+          { conversationId: args.conversationId, score: args.score }
+        ]);
+        await writeIndex(args.indexKey, next);
+      });
+    }
+  };
+}
+async function getConversationIndexStore(state) {
+  const redisStateAdapter = await getDefaultRedisStateAdapterFor(state);
+  if (redisStateAdapter) {
+    return redisConversationIndexStore(redisStateAdapter.getClient());
+  }
+  return emulatedConversationIndexStore(state);
+}
+async function upsertIndexEntry(args) {
+  const index4 = await getConversationIndexStore(args.state);
+  await index4.upsert({
+    conversationId: args.conversationId,
+    indexKey: args.indexKey,
+    score: args.score
+  });
+}
+async function removeIndexEntry(args) {
+  const index4 = await getConversationIndexStore(args.state);
+  await index4.remove({
+    conversationId: args.conversationId,
+    indexKey: args.indexKey
+  });
+}
+async function acquireMutationLock(state, conversationId) {
+  const startedAtMs = now();
+  while (true) {
+    const lock = await state.acquireLock(
+      mutationLockKey(conversationId),
+      CONVERSATION_MUTATION_LOCK_TTL_MS
+    );
+    if (lock) {
+      return lock;
+    }
+    if (now() - startedAtMs >= CONVERSATION_MUTATION_WAIT_MS) {
+      throw new Error(
+        `Could not acquire conversation mutation lock for ${conversationId}`
+      );
+    }
+    await sleep(CONVERSATION_MUTATION_RETRY_MS);
+  }
+}
+async function withConversationMutation(args, callback) {
+  const state = await getConnectedState(args.state);
+  const lock = await acquireMutationLock(state, args.conversationId);
+  try {
+    return await callback(state);
+  } finally {
+    await state.releaseLock(lock);
+  }
+}
+async function readConversation(state, conversationId) {
+  const raw = await state.get(conversationKey(conversationId));
+  if (raw == null) {
+    return void 0;
+  }
+  const conversation = normalizeConversation(conversationId, raw);
+  if (!conversation) {
+    throw new InvalidConversationRecordError(conversationId);
+  }
+  return conversation;
+}
+async function writeConversation(state, conversation) {
+  const execution = executionWithPendingMessages(
+    conversation.execution,
+    conversation.execution.pendingMessages
+  );
+  const next = {
+    ...conversation,
+    execution
+  };
+  await state.set(
+    conversationKey(next.conversationId),
+    next,
+    JUNIOR_THREAD_STATE_TTL_MS
+  );
+  await upsertIndexEntry({
+    state,
+    indexKey: CONVERSATION_BY_ACTIVITY_INDEX_KEY,
+    conversationId: next.conversationId,
+    score: next.lastActivityAtMs
+  });
+  if (!hasRunnableWork(next)) {
+    await removeIndexEntry({
+      state,
+      indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
+      conversationId: next.conversationId
+    });
+    return;
+  }
+  await upsertIndexEntry({
+    state,
+    indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
+    conversationId: next.conversationId,
+    score: next.execution.updatedAtMs ?? next.updatedAtMs
+  });
+}
+function assertSameConversationDestination(args) {
+  if (!args.current || sameDestination(args.current, args.next)) {
+    return;
+  }
+  throw new Error(
+    `Conversation destination changed for ${args.conversationId}`
+  );
+}
+function conversationWorkState(conversation) {
+  const lease = conversation.execution.lease;
+  return {
+    ...conversation,
+    lastEnqueuedAtMs: conversation.execution.lastEnqueuedAtMs,
+    ...lease ? {
+      lease: {
+        acquiredAtMs: lease.acquiredAtMs,
+        lastCheckInAtMs: lease.lastCheckInAtMs,
+        leaseExpiresAtMs: lease.expiresAtMs,
+        leaseToken: lease.token
+      }
+    } : {},
+    messages: pendingMessages(conversation),
+    needsRun: hasRunnableWork(conversation)
+  };
+}
+async function getConversation(args) {
+  const state = await getConnectedState(args.state);
+  return await readConversation(state, args.conversationId);
+}
+async function getConversationWorkState(args) {
+  const conversation = await getConversation(args);
+  return conversation ? conversationWorkState(conversation) : void 0;
+}
+async function appendInboundMessage(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(
+    { conversationId: args.message.conversationId, state: args.state },
+    async (state) => {
+      const current = await readConversation(state, args.message.conversationId) ?? emptyConversation({
+        conversationId: args.message.conversationId,
+        destination: args.message.destination,
+        nowMs,
+        source: args.message.source
+      });
+      assertSameConversationDestination({
+        conversationId: args.message.conversationId,
+        current: current.destination,
+        next: args.message.destination
+      });
+      const existingPending = current.execution.pendingMessages.some(
+        (message) => message.inboundMessageId === args.message.inboundMessageId
+      );
+      const existing = current.execution.inboundMessageIds.includes(
+        args.message.inboundMessageId
+      );
+      if (existing) {
+        if (!existingPending) {
+          return { status: "duplicate" };
+        }
+        const nextStatus = current.execution.status === "idle" ? "pending" : current.execution.status;
+        await writeConversation(
+          state,
+          withExecutionUpdate(
+            current,
+            {
+              ...current.execution,
+              status: nextStatus
+            },
+            nowMs
+          )
+        );
+        return { status: "duplicate" };
+      }
+      const status = current.execution.lease && current.execution.status === "running" ? "running" : current.execution.lease ? "awaiting_resume" : "pending";
+      const next = {
+        ...current,
+        destination: current.destination ?? args.message.destination,
+        source: current.source ?? args.message.source,
+        lastActivityAtMs: nowMs
+      };
+      await writeConversation(
+        state,
+        withExecutionUpdate(
+          next,
+          {
+            ...current.execution,
+            status,
+            inboundMessageIds: [
+              ...current.execution.inboundMessageIds,
+              args.message.inboundMessageId
+            ],
+            pendingMessages: [
+              ...current.execution.pendingMessages,
+              args.message
+            ].sort(compareMessages)
+          },
+          nowMs
+        )
+      );
+      return { status: "appended" };
+    }
+  );
+}
+async function requestConversationWork(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state) => {
+    const existing = await readConversation(state, args.conversationId);
+    if (existing) {
+      assertSameConversationDestination({
+        conversationId: args.conversationId,
+        current: existing.destination,
+        next: args.destination
+      });
+    }
+    const current = existing ?? emptyConversation({
+      conversationId: args.conversationId,
+      destination: args.destination,
+      nowMs
+    });
+    const status = current.execution.lease ? "awaiting_resume" : "pending";
+    await writeConversation(
+      state,
+      withExecutionUpdate(
+        {
+          ...current,
+          destination: current.destination ?? args.destination
+        },
+        {
+          ...current.execution,
+          status
+        },
+        nowMs
+      )
+    );
+    return { status: existing === void 0 ? "created" : "updated" };
+  });
+}
+async function recordConversationActivity(args) {
+  const nowMs = args.nowMs ?? now();
+  const activityAtMs = args.activityAtMs ?? nowMs;
+  await withConversationMutation(args, async (state) => {
+    const existing = await readConversation(state, args.conversationId);
+    if (existing && args.destination) {
+      assertSameConversationDestination({
+        conversationId: args.conversationId,
+        current: existing.destination,
+        next: args.destination
+      });
+    }
+    const current = existing ?? emptyConversation({
+      conversationId: args.conversationId,
+      destination: args.destination,
+      nowMs,
+      source: args.source
+    });
+    await writeConversation(state, {
+      ...current,
+      ...current.destination ?? args.destination ? { destination: current.destination ?? args.destination } : {},
+      ...current.source ?? args.source ? { source: current.source ?? args.source } : {},
+      ...current.channelName ?? args.channelName ? { channelName: current.channelName ?? args.channelName } : {},
+      ...current.requester ?? args.requester ? { requester: current.requester ?? args.requester } : {},
+      ...current.title ?? args.title ? { title: current.title ?? args.title } : {},
+      lastActivityAtMs: Math.max(current.lastActivityAtMs, activityAtMs),
+      updatedAtMs: nowMs,
+      execution: executionWithPendingMessages(
+        current.execution,
+        current.execution.pendingMessages
+      )
+    });
+  });
+}
+async function markConversationWorkEnqueued(args) {
+  const nowMs = args.nowMs ?? now();
+  await withConversationMutation(args, async (state) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current) {
+      return;
+    }
+    await writeConversation(
+      state,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lastEnqueuedAtMs: nowMs
+        },
+        nowMs
+      )
+    );
+  });
+}
+async function startConversationWork(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current) {
+      return { status: "no_work" };
+    }
+    if (isLeaseActive(current.execution.lease, nowMs)) {
+      return {
+        status: "active",
+        leaseExpiresAtMs: current.execution.lease.expiresAtMs
+      };
+    }
+    if (!hasRunnableWork(current)) {
+      return { status: "no_work" };
+    }
+    const lease = {
+      token: randomUUID(),
+      acquiredAtMs: nowMs,
+      lastCheckInAtMs: nowMs,
+      expiresAtMs: nowMs + CONVERSATION_WORK_LEASE_TTL_MS
+    };
+    await writeConversation(
+      state,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lease,
+          status: "running",
+          runId: current.execution.runId ?? randomUUID(),
+          lastEnqueuedAtMs: void 0
+        },
+        nowMs
+      )
+    );
+    return {
+      status: "acquired",
+      leaseToken: lease.token,
+      leaseExpiresAtMs: lease.expiresAtMs
+    };
+  });
+}
+async function checkInConversationWork(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      return false;
+    }
+    await writeConversation(
+      state,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lease: {
+            ...current.execution.lease,
+            lastCheckInAtMs: nowMs,
+            expiresAtMs: nowMs + CONVERSATION_WORK_LEASE_TTL_MS
+          }
+        },
+        nowMs
+      )
+    );
+    return true;
+  });
+}
+async function drainConversationMailbox(args) {
+  const nowMs = args.nowMs ?? now();
+  const pending = await withConversationMutation(args, async (state) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      throw new Error(
+        `Conversation lease is not held for ${args.conversationId}`
+      );
+    }
+    return pendingMessages(current);
+  });
+  if (pending.length === 0) {
+    return [];
+  }
+  await args.inject(pending);
+  await withConversationMutation(args, async (state) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      throw new Error(
+        `Conversation lease is not held for ${args.conversationId}`
+      );
+    }
+    const drainedIds = new Set(
+      pending.map((message) => message.inboundMessageId)
+    );
+    const pendingMessages2 = current.execution.pendingMessages.filter(
+      (message) => !drainedIds.has(message.inboundMessageId)
+    );
+    await writeConversation(
+      state,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          status: current.execution.status === "pending" && pendingMessages2.length === 0 ? "running" : current.execution.status,
+          pendingMessages: pendingMessages2
+        },
+        nowMs
+      )
+    );
+  });
+  return pending;
+}
+async function markConversationMessagesInjected(args) {
+  const nowMs = args.nowMs ?? now();
+  const inboundMessageIds = new Set(args.inboundMessageIds);
+  return await withConversationMutation(args, async (state) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      return false;
+    }
+    if (inboundMessageIds.size === 0) {
+      return true;
+    }
+    const pendingMessages2 = current.execution.pendingMessages.filter(
+      (message) => !inboundMessageIds.has(message.inboundMessageId)
+    );
+    if (pendingMessages2.length === current.execution.pendingMessages.length) {
+      return true;
+    }
+    await writeConversation(
+      state,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          pendingMessages: pendingMessages2
+        },
+        nowMs
+      )
+    );
+    return true;
+  });
+}
+async function requestConversationContinuation(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      return false;
+    }
+    assertSameConversationDestination({
+      conversationId: args.conversationId,
+      current: current.destination,
+      next: args.destination
+    });
+    await writeConversation(
+      state,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          status: "awaiting_resume"
+        },
+        nowMs
+      )
+    );
+    return true;
+  });
+}
+async function releaseConversationWork(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      return false;
+    }
+    await writeConversation(
+      state,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lease: void 0,
+          status: current.execution.status === "running" ? "pending" : current.execution.status
+        },
+        nowMs
+      )
+    );
+    return true;
+  });
+}
+async function completeConversationWork(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      return "lost_lease";
+    }
+    const hasPending = pendingMessages(current).length > 0;
+    const needsRun = current.execution.status === "awaiting_resume";
+    const runnable = needsRun || hasPending;
+    await writeConversation(
+      state,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lease: void 0,
+          status: runnable ? "pending" : "idle",
+          runId: runnable ? current.execution.runId : void 0
+        },
+        nowMs
+      )
+    );
+    return runnable ? "pending" : "completed";
+  });
+}
+async function clearExpiredConversationLease(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current?.execution.lease || current.execution.lease.expiresAtMs > nowMs) {
+      return false;
+    }
+    await writeConversation(
+      state,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lease: void 0,
+          status: "pending"
+        },
+        nowMs
+      )
+    );
+    return true;
+  });
+}
+async function removeActiveConversation(args) {
+  const state = await getConnectedState(args.state);
+  await removeIndexEntry({
+    state,
+    indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
+    conversationId: args.conversationId
+  });
+}
+async function listActiveConversationIds(args = {}) {
+  const state = await getConnectedState(args.state);
+  const index4 = await getConversationIndexStore(state);
+  const entries = await index4.list({
+    indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
+    limit: args.limit,
+    order: "asc",
+    scoreMax: args.staleBeforeMs
+  });
+  return entries.map((entry) => entry.conversationId);
+}
+async function listConversationsByActivity(args = {}) {
+  const state = await getConnectedState(args.state);
+  const index4 = await getConversationIndexStore(state);
+  const entries = await index4.list({
+    indexKey: CONVERSATION_BY_ACTIVITY_INDEX_KEY,
+    limit: args.limit ?? CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH,
+    offset: args.offset,
+    order: "desc"
+  });
+  const conversations = [];
+  for (const entry of entries) {
+    try {
+      const conversation = await readConversation(state, entry.conversationId);
+      if (conversation) {
+        conversations.push(conversation);
+      }
+    } catch (error) {
+      if (!(error instanceof InvalidConversationRecordError)) {
+        throw error;
+      }
+      await removeIndexEntry({
+        state,
+        indexKey: CONVERSATION_BY_ACTIVITY_INDEX_KEY,
+        conversationId: entry.conversationId
+      });
+    }
+  }
+  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 as sql2 } 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 = sql2`coalesce(excluded.execution_updated_at, excluded.updated_at)`;
+    const currentExecutionVersion = sql2`coalesce(${juniorConversations.executionUpdatedAt}, ${juniorConversations.updatedAt})`;
+    const incomingExecutionIsFresh = sql2`${incomingExecutionVersion} >= ${currentExecutionVersion}`;
+    const destinationId = await this.upsertDestination(
+      destinationUpsertFromDestination({
+        channelName: conversation.channelName,
+        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: sql2`coalesce(excluded.source, ${juniorConversations.source})`,
+        originType: sql2`coalesce(excluded.origin_type, ${juniorConversations.originType})`,
+        originId: sql2`coalesce(excluded.origin_id, ${juniorConversations.originId})`,
+        originRunId: sql2`coalesce(excluded.origin_run_id, ${juniorConversations.originRunId})`,
+        destinationId: sql2`coalesce(excluded.destination_id, ${juniorConversations.destinationId})`,
+        destination: sql2`coalesce(excluded.destination_json, ${juniorConversations.destination})`,
+        actorIdentityId: sql2`coalesce(excluded.actor_identity_id, ${juniorConversations.actorIdentityId})`,
+        requesterIdentityId: sql2`coalesce(excluded.requester_identity_id, ${juniorConversations.requesterIdentityId})`,
+        creatorIdentityId: sql2`coalesce(excluded.creator_identity_id, ${juniorConversations.creatorIdentityId})`,
+        credentialSubjectIdentityId: sql2`coalesce(excluded.credential_subject_identity_id, ${juniorConversations.credentialSubjectIdentityId})`,
+        requester: sql2`coalesce(excluded.requester_json, ${juniorConversations.requester})`,
+        channelName: sql2`coalesce(excluded.channel_name, ${juniorConversations.channelName})`,
+        title: sql2`coalesce(excluded.title, ${juniorConversations.title})`,
+        createdAt: sql2`least(${juniorConversations.createdAt}, excluded.created_at)`,
+        lastActivityAt: sql2`greatest(${juniorConversations.lastActivityAt}, excluded.last_activity_at)`,
+        updatedAt: sql2`greatest(${juniorConversations.updatedAt}, excluded.updated_at)`,
+        executionUpdatedAt: sql2`case when ${incomingExecutionIsFresh} then excluded.execution_updated_at else ${juniorConversations.executionUpdatedAt} end`,
+        executionStatus: sql2`case when ${incomingExecutionIsFresh} then excluded.execution_status else ${juniorConversations.executionStatus} end`,
+        runId: sql2`case when ${incomingExecutionIsFresh} then excluded.run_id else ${juniorConversations.runId} end`,
+        lastCheckpointAt: sql2`case when ${incomingExecutionIsFresh} then excluded.last_checkpoint_at else ${juniorConversations.lastCheckpointAt} end`,
+        lastEnqueuedAt: sql2`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: sql2`excluded.kind`,
+        displayName: sql2`coalesce(excluded.display_name, ${juniorIdentities.displayName})`,
+        handle: sql2`coalesce(excluded.handle, ${juniorIdentities.handle})`,
+        email: sql2`coalesce(excluded.email, ${juniorIdentities.email})`,
+        avatarUrl: sql2`coalesce(excluded.avatar_url, ${juniorIdentities.avatarUrl})`,
+        metadata: sql2`coalesce(excluded.metadata_json, ${juniorIdentities.metadata})`,
+        updatedAt: sql2`excluded.updated_at`
+      }
+    }).returning({ id: juniorIdentities.id });
+    return rows[0]?.id;
+  }
+  async upsertDestination(destination, nowMs) {
+    if (!destination) {
+      return void 0;
+    }
+    const 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: sql2`excluded.kind`,
+        displayName: sql2`coalesce(excluded.display_name, ${juniorDestinations.displayName})`,
+        visibility: sql2`excluded.visibility`,
+        metadata: sql2`coalesce(excluded.metadata_json, ${juniorDestinations.metadata})`,
+        updatedAt: sql2`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,
+  createNeonJuniorSqlExecutor,
+  CONVERSATION_WORK_CHECK_IN_INTERVAL_MS,
+  CONVERSATION_WORK_STALE_ENQUEUE_MS,
+  getConversation,
+  getConversationWorkState,
+  appendInboundMessage,
+  requestConversationWork,
+  markConversationWorkEnqueued,
+  startConversationWork,
+  checkInConversationWork,
+  drainConversationMailbox,
+  markConversationMessagesInjected,
+  requestConversationContinuation,
+  releaseConversationWork,
+  completeConversationWork,
+  clearExpiredConversationLease,
+  removeActiveConversation,
+  listActiveConversationIds,
+  createStateConversationStore,
+  createSqlStore
+};