@opengeni/db 0.6.0 → 0.7.0

package/dist/chunk-ZIUCA2IO.js

@@ -1,1268 +0,0 @@
-import {
-  __export
-} from "./chunk-PZ5AY32C.js";
-
-// src/schema.ts
-var schema_exports = {};
-__export(schema_exports, {
-  agentRunStates: () => agentRunStates,
-  apiKeys: () => apiKeys,
-  auditEvents: () => auditEvents,
-  billingCustomers: () => billingCustomers,
-  capabilityCatalogItems: () => capabilityCatalogItems,
-  capabilityInstallations: () => capabilityInstallations,
-  codexRotationSettings: () => codexRotationSettings,
-  codexSubscriptionCredentials: () => codexSubscriptionCredentials,
-  connections: () => connections,
-  creditLedgerEntries: () => creditLedgerEntries,
-  deviceEnrollmentRequests: () => deviceEnrollmentRequests,
-  deviceEnrollmentStatusValues: () => deviceEnrollmentStatusValues,
-  documentBases: () => documentBases,
-  documentChunks: () => documentChunks,
-  documents: () => documents,
-  enrollmentExposureValues: () => enrollmentExposureValues,
-  enrollmentOsValues: () => enrollmentOsValues,
-  enrollmentStatusValues: () => enrollmentStatusValues,
-  enrollments: () => enrollments,
-  fileUploads: () => fileUploads,
-  files: () => files,
-  githubInstallations: () => githubInstallations,
-  importBatches: () => importBatches,
-  integrationOauthClients: () => integrationOauthClients,
-  integrationOauthStateNonces: () => integrationOauthStateNonces,
-  knowledgeMemories: () => knowledgeMemories,
-  machineMetricsLatest: () => machineMetricsLatest,
-  machineMetricsSeries: () => machineMetricsSeries,
-  managedAccounts: () => managedAccounts,
-  packInstallations: () => packInstallations,
-  sandboxKindValues: () => sandboxKindValues,
-  sandboxLeaseHolders: () => sandboxLeaseHolders,
-  sandboxLeaseLivenessValues: () => sandboxLeaseLivenessValues,
-  sandboxLeases: () => sandboxLeases,
-  sandboxPtySessions: () => sandboxPtySessions,
-  sandboxSessionEnvelopes: () => sandboxSessionEnvelopes,
-  sandboxes: () => sandboxes,
-  scheduledTaskRuns: () => scheduledTaskRuns,
-  scheduledTasks: () => scheduledTasks,
-  sessionEvents: () => sessionEvents,
-  sessionGoals: () => sessionGoals,
-  sessionHistoryItems: () => sessionHistoryItems,
-  sessionMcpServers: () => sessionMcpServers,
-  sessionRecordingCodecValues: () => sessionRecordingCodecValues,
-  sessionRecordingModeValues: () => sessionRecordingModeValues,
-  sessionRecordingStateValues: () => sessionRecordingStateValues,
-  sessionRecordings: () => sessionRecordings,
-  sessionTurns: () => sessionTurns,
-  sessions: () => sessions,
-  socialConnections: () => socialConnections,
-  socialPosts: () => socialPosts,
-  stripeWebhookEvents: () => stripeWebhookEvents,
-  usageEvents: () => usageEvents,
-  workspaceEnvironmentVariables: () => workspaceEnvironmentVariables,
-  workspaceEnvironments: () => workspaceEnvironments,
-  workspaceMemberships: () => workspaceMemberships,
-  workspacePacks: () => workspacePacks,
-  workspaces: () => workspaces
-});
-import { sql } from "drizzle-orm";
-import { bigint, boolean, index, integer, jsonb, numeric, pgTable, text, timestamp, uniqueIndex, uuid, customType } from "drizzle-orm/pg-core";
-var vector = customType({
-  dataType() {
-    return "vector(3072)";
-  },
-  toDriver(value) {
-    return `[${value.join(",")}]`;
-  }
-});
-var managedAccounts = pgTable("managed_accounts", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  name: text("name").notNull(),
-  externalSource: text("external_source"),
-  externalId: text("external_id"),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  external: uniqueIndex("managed_accounts_external_idx").on(table.externalSource, table.externalId)
-}));
-var workspaces = pgTable("workspaces", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  name: text("name").notNull(),
-  slug: text("slug"),
-  externalSource: text("external_source"),
-  externalId: text("external_id"),
-  // White-label agent persona template override. NULL means the deployment
-  // default (OPENGENI_AGENT_INSTRUCTIONS_TEMPLATE / DEFAULT_AGENT_INSTRUCTIONS).
-  agentInstructions: text("agent_instructions"),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  account: index("workspaces_account_idx").on(table.accountId),
-  accountSlug: uniqueIndex("workspaces_account_slug_idx").on(table.accountId, table.slug).where(sql`${table.slug} is not null`),
-  external: uniqueIndex("workspaces_external_idx").on(table.externalSource, table.externalId)
-}));
-var workspaceMemberships = pgTable("workspace_memberships", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  subjectId: text("subject_id").notNull(),
-  subjectLabel: text("subject_label"),
-  role: text("role").notNull().default("member"),
-  permissions: jsonb("permissions").$type().notNull().default([]),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  subjectWorkspace: uniqueIndex("workspace_memberships_subject_workspace_idx").on(table.subjectId, table.workspaceId),
-  subject: index("workspace_memberships_subject_idx").on(table.subjectId),
-  account: index("workspace_memberships_account_idx").on(table.accountId)
-}));
-var apiKeys = pgTable("api_keys", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").references(() => workspaces.id, { onDelete: "cascade" }),
-  name: text("name").notNull(),
-  prefix: text("prefix").notNull(),
-  keyHash: text("key_hash").notNull(),
-  permissions: jsonb("permissions").$type().notNull().default([]),
-  expiresAt: timestamp("expires_at", { withTimezone: true }),
-  revokedAt: timestamp("revoked_at", { withTimezone: true }),
-  lastUsedAt: timestamp("last_used_at", { withTimezone: true }),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  prefix: index("api_keys_prefix_idx").on(table.prefix),
-  hash: uniqueIndex("api_keys_key_hash_idx").on(table.keyHash),
-  account: index("api_keys_account_idx").on(table.accountId),
-  workspace: index("api_keys_workspace_idx").on(table.workspaceId)
-}));
-var workspaceEnvironments = pgTable("workspace_environments", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  name: text("name").notNull(),
-  description: text("description"),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  workspaceName: uniqueIndex("workspace_environments_workspace_name_idx").on(table.workspaceId, table.name),
-  workspaceCreated: index("workspace_environments_workspace_created_idx").on(table.workspaceId, table.createdAt)
-}));
-var workspaceEnvironmentVariables = pgTable("workspace_environment_variables", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  environmentId: uuid("environment_id").notNull().references(() => workspaceEnvironments.id, { onDelete: "cascade" }),
-  name: text("name").notNull(),
-  // Format: v1:<base64 iv>:<base64 ciphertext||gcm-tag>. Never returned by any API.
-  valueEncrypted: text("value_encrypted").notNull(),
-  version: integer("version").notNull().default(1),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  environmentName: uniqueIndex("workspace_environment_variables_env_name_idx").on(table.workspaceId, table.environmentId, table.name),
-  environment: index("workspace_environment_variables_workspace_env_idx").on(table.workspaceId, table.environmentId)
-}));
-var codexSubscriptionCredentials = pgTable("codex_subscription_credentials", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  // Format: v1:<base64 iv>:<base64 ciphertext||gcm-tag>. JSON {access_token, refresh_token, id_token}. Never returned by any API.
-  credentialEncrypted: text("credential_encrypted").notNull(),
-  chatgptAccountId: text("chatgpt_account_id"),
-  // plaintext ChatGPT-Account-ID header value (non-secret)
-  scopes: text("scopes"),
-  // space-delimited, as granted
-  planType: text("plan_type"),
-  isFedramp: boolean("is_fedramp").notNull().default(false),
-  expiresAt: timestamp("expires_at", { withTimezone: true }),
-  // derived from access-token JWT exp
-  lastRefreshAt: timestamp("last_refresh_at", { withTimezone: true }),
-  status: text("status").notNull().default("active"),
-  // active | needs_relogin | error
-  lastError: text("last_error"),
-  version: integer("version").notNull().default(1),
-  label: text("label"),
-  // user-chosen nickname; null ⇒ derive from email/plan/account
-  accountEmail: text("account_email"),
-  // email from the id_token (user's own email; non-secret)
-  // P2 usage cache (plaintext metadata; NEVER a token). Snapshotted from
-  // GET /wham/usage; drives the quota bars + the cache TTL. primary = 5h window
-  // (limit_window_seconds 18000), secondary = weekly (604800).
-  primaryUsedPercent: integer("primary_used_percent"),
-  primaryResetAt: timestamp("primary_reset_at", { withTimezone: true }),
-  secondaryUsedPercent: integer("secondary_used_percent"),
-  secondaryResetAt: timestamp("secondary_reset_at", { withTimezone: true }),
-  usageCheckedAt: timestamp("usage_checked_at", { withTimezone: true }),
-  // snapshot freshness → cache TTL clock
-  // P3 rotation cooldown (plaintext metadata; NEVER a token). Set when this account hit its
-  // usage cap on a rotation turn; the rotation engine treats `exhausted_until > now()` as
-  // capped/skip so it isn't immediately re-picked. Self-clears via the now() comparison.
-  exhaustedUntil: timestamp("exhausted_until", { withTimezone: true }),
-  // P4 connector-aware rotation cache (plaintext metadata; NEVER a token). The set
-  // of ORIGINAL-dotted connector namespaces (github/gmail/linear/…) this account
-  // exposes via codex_apps, captured from the per-turn tools/list. null ⇒ never
-  // probed (the ranker treats it as unknown: never credited as covering, never
-  // excluded). The writer only ever sets a NON-empty set, so a flaky empty turn
-  // can't false-drop coverage. connectorsCheckedAt is the freshness clock.
-  connectorNamespaces: text("connector_namespaces").array(),
-  connectorsCheckedAt: timestamp("connectors_checked_at", { withTimezone: true }),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  // REPLACES codex_subscription_credentials_workspace_idx (the one-per-workspace cap).
-  // One row per (workspace, ChatGPT account). Partial WHERE chatgpt_account_id IS NOT NULL
-  // so degenerate null-account rows can't collide; the device-grant connect path always
-  // populates chatgpt_account_id.
-  wsAccount: uniqueIndex("codex_subscription_credentials_ws_account_idx").on(table.workspaceId, table.chatgptAccountId).where(sql`${table.chatgptAccountId} is not null`),
-  workspace: index("codex_subscription_credentials_workspace_lookup_idx").on(table.workspaceId)
-}));
-var connections = pgTable("connections", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  subjectId: text("subject_id"),
-  providerDomain: text("provider_domain").notNull(),
-  kind: text("kind").notNull(),
-  status: text("status").notNull().default("active"),
-  credentialEncrypted: text("credential_encrypted").notNull(),
-  grantedScopes: jsonb("granted_scopes").$type().notNull().default([]),
-  expiresAt: timestamp("expires_at", { withTimezone: true }),
-  lastRefreshAt: timestamp("last_refresh_at", { withTimezone: true }),
-  lastUsedAt: timestamp("last_used_at", { withTimezone: true }),
-  lastError: text("last_error"),
-  version: integer("version").notNull().default(1),
-  metadata: jsonb("metadata").$type().notNull().default({}),
-  createdBySubjectId: text("created_by_subject_id"),
-  updatedBySubjectId: text("updated_by_subject_id"),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  workspaceProviderStatus: index("connections_workspace_provider_status_idx").on(table.workspaceId, table.providerDomain, table.status),
-  workspaceSubjectProvider: index("connections_workspace_subject_provider_idx").on(table.workspaceId, table.subjectId, table.providerDomain),
-  workspaceKind: index("connections_workspace_kind_idx").on(table.workspaceId, table.kind),
-  workspaceExpires: index("connections_workspace_expires_idx").on(table.workspaceId, table.expiresAt)
-}));
-var integrationOauthClients = pgTable("integration_oauth_clients", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  issuer: text("issuer").notNull(),
-  authorizationServer: text("authorization_server").notNull(),
-  clientId: text("client_id").notNull(),
-  clientSecretEncrypted: text("client_secret_encrypted"),
-  tokenEndpointAuthMethod: text("token_endpoint_auth_method").notNull().default("none"),
-  metadata: jsonb("metadata").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  issuer: uniqueIndex("integration_oauth_clients_issuer_idx").on(table.issuer),
-  authorizationServer: index("integration_oauth_clients_as_idx").on(table.authorizationServer)
-}));
-var integrationOauthStateNonces = pgTable("integration_oauth_state_nonces", {
-  nonce: text("nonce").primaryKey(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  subjectId: text("subject_id").notNull(),
-  expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
-  usedAt: timestamp("used_at", { withTimezone: true }).notNull().defaultNow(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  workspace: index("integration_oauth_state_nonces_workspace_idx").on(table.workspaceId),
-  expires: index("integration_oauth_state_nonces_expires_idx").on(table.expiresAt)
-}));
-var codexRotationSettings = pgTable("codex_rotation_settings", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  activeCredentialId: uuid("active_credential_id"),
-  rotationEnabled: boolean("rotation_enabled").notNull().default(false),
-  // P3, inert in P1
-  rotationStrategy: text("rotation_strategy").notNull().default("most_remaining"),
-  // P3, inert
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  workspace: uniqueIndex("codex_rotation_settings_workspace_idx").on(table.workspaceId)
-}));
-var sessions = pgTable("sessions", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  status: text("status").notNull().default("queued"),
-  initialMessage: text("initial_message").notNull(),
-  title: text("title"),
-  titleSource: text("title_source"),
-  // Per-session agent persona/system instructions supplied at create (the
-  // per-agent-type prompt lever for embedding hosts). NULL ⇒ the session
-  // carried none, so the composed agent instructions are byte-identical to a
-  // workspace-only persona (no backfill, no behavior change for existing rows).
-  // Composed system-level AFTER the workspace agentInstructions; never emitted
-  // as a timeline event.
-  instructions: text("instructions"),
-  resources: jsonb("resources").$type().notNull().default([]),
-  tools: jsonb("tools").$type().notNull().default([]),
-  metadata: jsonb("metadata").$type().notNull().default({}),
-  model: text("model").notNull(),
-  sandboxBackend: text("sandbox_backend").notNull(),
-  // The OS this session's box runs. Defaults to 'linux' (today's only OS, so
-  // every existing + new row is a behavior-preserving no-op). CHECK-constrained
-  // to the SandboxOs enum (linux|macos|windows) in migration 0018.
-  sandboxOs: text("sandbox_os").notNull().default("linux"),
-  // The shared-sandbox group this session's box belongs to. Defaults to the
-  // session's OWN id (a singleton group: group === session — today's 1:1
-  // behavior). When spawned shared via session_create, set to the PARENT's
-  // sandboxGroupId so both run in ONE box. Immutable once set. NOT an FK (the
-  // value is this row's id or an ancestor session's id in the same workspace;
-  // the live lease row, not a sandbox_groups table, materializes the group).
-  // The app generates the uuid and uses it for both id and sandbox_group_id in
-  // one insert — it cannot SQL-default to id (id is defaultRandom()).
-  sandboxGroupId: uuid("sandbox_group_id").notNull(),
-  // The first-class swappable-sandbox POINTER (bring-your-own-compute M2,
-  // dossier §10.3). NULL == "use the session's own group sandbox" (the
-  // backward-compat default — every existing/new row is a behavior-preserving
-  // no-op). The routing proxy re-reads (active_sandbox_id, active_epoch) PER
-  // TOOL CALL to make a Modal<->selfhosted hot-swap seamless. The FK
-  // (-> sandboxes(id) ON DELETE SET NULL — a deleted sandbox degrades the
-  // pointer to the group default, never dangles) lives in migration 0024, NOT a
-  // Drizzle .references() — exactly like parentSessionId below, so the const
-  // ordering imposes no forward-reference.
-  activeSandboxId: uuid("active_sandbox_id"),
-  // The SECOND epoch ABOVE sandbox_leases.lease_epoch, bumped on every swap; an
-  // in-flight op fenced by a stale active_epoch retries against the new active
-  // sandbox. integer (NOT bigint) — the lease-epoch spike: int8 reads back as a
-  // JS string and breaks the strict fence; int4 returns a number.
-  activeEpoch: integer("active_epoch").notNull().default(0),
-  // The session's WORKING DIRECTORY — the path/cwd base the (selfhosted) box's
-  // agent/terminal/file-dock operate under. A launch-workspace_root-relative
-  // subdir or an absolute machine path; surfaced alongside the active-sandbox
-  // pointer (readActiveSandbox) and written through the epoch-fenced
-  // setActiveSandbox CAS, NOT the row INSERT. NULL (the default) ⇒ today's
-  // behavior exactly — the agent substitutes its workspace_root for an empty cwd,
-  // so an unset working_dir is a byte-identical no-op. Create-time only (Stage A).
-  workingDir: text("working_dir"),
-  environmentId: uuid("environment_id").references(() => workspaceEnvironments.id, { onDelete: "set null" }),
-  // Non-default first-party MCP token permissions (manager-style sessions);
-  // null means the fixed worker default set in @opengeni/runtime.
-  firstPartyMcpPermissions: jsonb("first_party_mcp_permissions").$type(),
-  // The manager session that spawned this one via session_create. Set only
-  // when the creating grant carried a worker-signed sessionId claim (a session
-  // spawning a worker); null for direct API creates and scheduled-task runs.
-  // When set, this worker's terminal-for-now transitions wake the parent so a
-  // manager can orchestrate workers without busy-polling. Self-referencing FK,
-  // ON DELETE SET NULL so deleting a manager never cascades into its workers.
-  parentSessionId: uuid("parent_session_id"),
-  // Workspace-scoped CREATE idempotency key. NULL means the create carried no
-  // key (each such create is independent). When set, the partial unique index
-  // below collapses concurrent/retried creates with the same key in the same
-  // workspace to a single session row — the dedup that closes the
-  // double-submit/double-dispatch stuck-queued bug.
-  createIdempotencyKey: text("create_idempotency_key"),
-  temporalWorkflowId: text("temporal_workflow_id"),
-  activeTurnId: uuid("active_turn_id"),
-  // Actual input tokens reported for the last model call of the most recent
-  // turn. The pre-turn client-side compaction trigger reads this as its budget
-  // signal (char/4 estimate is the same-turn fallback). Null until a turn with
-  // usage has completed.
-  lastInputTokens: integer("last_input_tokens"),
-  // Operator /compact request flag (client-side compaction path). The API sets
-  // it true; the worker honors it BEFORE the next turn's model call by forcing
-  // a compaction, then clears it. A durable flag (not a transient signal) so
-  // the trigger survives a worker restart and converges before the next turn.
-  compactRequested: boolean("compact_requested").notNull().default(false),
-  lastSequence: integer("last_sequence").notNull().default(0),
-  // The session's PINNED Codex account (manual override from the in-session
-  // switcher). NULL ⇒ follow the workspace active pointer. FK declared in the
-  // migration with ON DELETE SET NULL (a disconnected pin degrades to "follow
-  // active", never dangles), same pattern as activeSandboxId.
-  codexPinnedCredentialId: uuid("codex_pinned_credential_id"),
-  // The Codex account the session's most recent turn ACTUALLY ran on — drives
-  // the "Running on:" indicator. Written by the worker at the turn boundary. FK
-  // ON DELETE SET NULL (migration).
-  codexLastCredentialId: uuid("codex_last_credential_id"),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  workspaceCreated: index("sessions_workspace_created_idx").on(table.workspaceId, table.createdAt),
-  environment: index("sessions_environment_idx").on(table.workspaceId, table.environmentId),
-  parent: index("sessions_parent_idx").on(table.workspaceId, table.parentSessionId),
-  // Routing index: resolve session_id -> sandbox_group_id at every lease entry
-  // point and enumerate all sessions in a group for attribution/disclosure.
-  sandboxGroup: index("sessions_sandbox_group_idx").on(table.workspaceId, table.sandboxGroupId),
-  // Partial unique index: one session per (workspace, create_idempotency_key)
-  // when a key is present. Concurrent creates racing on the same key see a
-  // unique violation on all but one; the domain layer catches it and returns
-  // the winning row instead of erroring.
-  createIdempotency: uniqueIndex("sessions_workspace_create_idempotency_idx").on(table.workspaceId, table.createIdempotencyKey).where(sql`${table.createIdempotencyKey} is not null`)
-}));
-var sessionMcpServers = pgTable("session_mcp_servers", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  sessionId: uuid("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  serverId: text("server_id").notNull(),
-  name: text("name"),
-  url: text("url").notNull(),
-  allowedTools: jsonb("allowed_tools").$type(),
-  timeoutMs: integer("timeout_ms"),
-  cacheToolsList: boolean("cache_tools_list").notNull().default(false),
-  // Human-approval policy: `true` = every tool requires approval, a string[] of
-  // UNPREFIXED tool names = only those require it, null/absent = auto-run.
-  requireApproval: jsonb("require_approval").$type(),
-  // Map of header name -> AES-GCM ciphertext. Values are decrypted only by the
-  // worker's run-preparation path and never returned by API helpers.
-  headersEncrypted: jsonb("headers_encrypted").$type().notNull().default({}),
-  credentialVersion: integer("credential_version").notNull().default(1),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  sessionServer: uniqueIndex("session_mcp_servers_session_server_idx").on(table.workspaceId, table.sessionId, table.serverId),
-  session: index("session_mcp_servers_session_idx").on(table.workspaceId, table.sessionId)
-}));
-var files = pgTable("files", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  status: text("status").notNull().default("pending_upload"),
-  filename: text("filename").notNull(),
-  safeFilename: text("safe_filename").notNull(),
-  contentType: text("content_type").notNull(),
-  sizeBytes: bigint("size_bytes", { mode: "number" }).notNull(),
-  sha256: text("sha256"),
-  bucket: text("bucket").notNull(),
-  objectKey: text("object_key").notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  workspaceCreated: index("files_workspace_created_idx").on(table.workspaceId, table.createdAt),
-  objectKey: uniqueIndex("files_object_key_idx").on(table.objectKey),
-  status: index("files_status_idx").on(table.status)
-}));
-var fileUploads = pgTable("file_uploads", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  fileId: uuid("file_id").notNull().references(() => files.id, { onDelete: "cascade" }),
-  status: text("status").notNull().default("pending"),
-  expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
-  completedAt: timestamp("completed_at", { withTimezone: true }),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  workspace: index("file_uploads_workspace_idx").on(table.workspaceId),
-  fileId: index("file_uploads_file_id_idx").on(table.fileId),
-  status: index("file_uploads_status_idx").on(table.status)
-}));
-var documentBases = pgTable("document_bases", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  name: text("name").notNull(),
-  description: text("description"),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  workspaceCreated: index("document_bases_workspace_created_idx").on(table.workspaceId, table.createdAt)
-}));
-var documents = pgTable("documents", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  baseId: uuid("base_id").notNull().references(() => documentBases.id, { onDelete: "cascade" }),
-  fileId: uuid("file_id").notNull().references(() => files.id, { onDelete: "restrict" }),
-  status: text("status").notNull().default("queued"),
-  title: text("title").notNull(),
-  parser: text("parser").notNull().default("liteparse"),
-  chunkCount: integer("chunk_count").notNull().default(0),
-  error: text("error"),
-  sourceKind: text("source_kind").notNull().default("manual_upload"),
-  sourceUri: text("source_uri"),
-  sourceExternalId: text("source_external_id"),
-  sourceTitle: text("source_title"),
-  sourceAuthor: text("source_author"),
-  sourceCreatedAt: timestamp("source_created_at", { withTimezone: true }),
-  sourceUpdatedAt: timestamp("source_updated_at", { withTimezone: true }),
-  sourceVersion: text("source_version"),
-  aclTags: jsonb("acl_tags").$type().notNull().default([]),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  baseFile: uniqueIndex("documents_workspace_base_file_idx").on(table.workspaceId, table.baseId, table.fileId),
-  baseStatus: index("documents_workspace_base_status_idx").on(table.workspaceId, table.baseId, table.status),
-  sourceKind: index("documents_workspace_source_kind_idx").on(table.workspaceId, table.sourceKind),
-  sourceExternalId: index("documents_workspace_source_external_id_idx").on(table.workspaceId, table.sourceExternalId)
-}));
-var documentChunks = pgTable("document_chunks", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  documentId: uuid("document_id").notNull().references(() => documents.id, { onDelete: "cascade" }),
-  baseId: uuid("base_id").notNull().references(() => documentBases.id, { onDelete: "cascade" }),
-  fileId: uuid("file_id").notNull().references(() => files.id, { onDelete: "restrict" }),
-  chunkIndex: integer("chunk_index").notNull(),
-  text: text("text").notNull(),
-  metadata: jsonb("metadata").$type().notNull().default({}),
-  embedding: vector("embedding").notNull(),
-  embeddingModel: text("embedding_model").notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  documentIndex: uniqueIndex("document_chunks_workspace_document_index_idx").on(table.workspaceId, table.documentId, table.chunkIndex),
-  base: index("document_chunks_workspace_base_idx").on(table.workspaceId, table.baseId)
-}));
-var knowledgeMemories = pgTable("knowledge_memories", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  status: text("status").notNull().default("proposed"),
-  kind: text("kind").notNull().default("semantic"),
-  scope: text("scope").notNull().default("workspace"),
-  text: text("text").notNull(),
-  sourceRefs: jsonb("source_refs").$type().notNull().default([]),
-  confidence: integer("confidence").notNull().default(50),
-  metadata: jsonb("metadata").$type().notNull().default({}),
-  createdBySessionId: uuid("created_by_session_id").references(() => sessions.id, { onDelete: "set null" }),
-  reviewedBy: text("reviewed_by"),
-  reviewedAt: timestamp("reviewed_at", { withTimezone: true }),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  workspaceStatus: index("knowledge_memories_workspace_status_idx").on(table.workspaceId, table.status, table.updatedAt),
-  workspaceKind: index("knowledge_memories_workspace_kind_idx").on(table.workspaceId, table.kind),
-  workspaceScope: index("knowledge_memories_workspace_scope_idx").on(table.workspaceId, table.scope),
-  createdBySession: index("knowledge_memories_workspace_created_by_session_idx").on(table.workspaceId, table.createdBySessionId)
-}));
-var sessionTurns = pgTable("session_turns", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  sessionId: uuid("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  triggerEventId: uuid("trigger_event_id").notNull(),
-  temporalWorkflowId: text("temporal_workflow_id").notNull(),
-  status: text("status").notNull(),
-  source: text("source").notNull().default("user"),
-  position: integer("position").notNull(),
-  prompt: text("prompt").notNull(),
-  resources: jsonb("resources").$type().notNull().default([]),
-  tools: jsonb("tools").$type().notNull().default([]),
-  model: text("model").notNull(),
-  reasoningEffort: text("reasoning_effort").notNull(),
-  sandboxBackend: text("sandbox_backend").notNull(),
-  // Per-turn OS override. NULL = inherit the session's sandbox_os. CHECK-
-  // constrained to the SandboxOs enum (or NULL) in migration 0018.
-  sandboxOs: text("sandbox_os"),
-  metadata: jsonb("metadata").$type().notNull().default({}),
-  // Atomic per-turn toolspace call budget counter (migration 0043). Incremented
-  // by a single conditional UPDATE at tools/call time; the row lock serializes
-  // concurrent reservations so exactly `toolspaceMaxCallsPerTurn` succeed.
-  toolspaceCallCount: integer("toolspace_call_count").notNull().default(0),
-  startedAt: timestamp("started_at", { withTimezone: true }),
-  finishedAt: timestamp("finished_at", { withTimezone: true }),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  queue: index("session_turns_workspace_queue_idx").on(table.workspaceId, table.sessionId, table.status, table.position)
-}));
-var sessionGoals = pgTable("session_goals", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  sessionId: uuid("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  status: text("status").notNull().default("active"),
-  // active | paused | completed
-  text: text("text").notNull(),
-  successCriteria: text("success_criteria"),
-  evidence: text("evidence"),
-  // set by goal_complete
-  rationale: text("rationale"),
-  // set by goal_pause
-  pausedReason: text("paused_reason"),
-  // agent | user_interrupt | api | no_progress | max_auto_continuations | limits
-  createdBy: text("created_by").notNull().default("api"),
-  // api | agent | scheduled_task
-  version: integer("version").notNull().default(1),
-  // bumped on every set/update; progress signal
-  autoContinuations: integer("auto_continuations").notNull().default(0),
-  noProgressStreak: integer("no_progress_streak").notNull().default(0),
-  maxAutoContinuations: integer("max_auto_continuations"),
-  // per-goal override; a configured settings cap (if any) remains the hard ceiling
-  lastContinuationTurnId: uuid("last_continuation_turn_id"),
-  versionAtLastContinuation: integer("version_at_last_continuation"),
-  metadata: jsonb("metadata").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  workspaceSession: uniqueIndex("session_goals_workspace_session_idx").on(table.workspaceId, table.sessionId),
-  status: index("session_goals_workspace_status_idx").on(table.workspaceId, table.status)
-}));
-var sessionEvents = pgTable("session_events", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  sessionId: uuid("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  turnId: uuid("turn_id"),
-  sequence: integer("sequence").notNull(),
-  type: text("type").notNull(),
-  payload: jsonb("payload").$type().notNull().default({}),
-  clientEventId: text("client_event_id"),
-  producerId: text("producer_id"),
-  producerSeq: integer("producer_seq"),
-  occurredAt: timestamp("occurred_at", { withTimezone: true }).notNull().defaultNow(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  sessionSequence: uniqueIndex("session_events_workspace_session_sequence_idx").on(table.workspaceId, table.sessionId, table.sequence),
-  clientEvent: uniqueIndex("session_events_workspace_client_event_idx").on(table.workspaceId, table.sessionId, table.clientEventId).where(sql`${table.clientEventId} is not null`),
-  producer: uniqueIndex("session_events_workspace_producer_idx").on(table.workspaceId, table.sessionId, table.producerId, table.producerSeq).where(sql`${table.producerId} is not null and ${table.producerSeq} is not null`),
-  sessionCreated: index("session_events_workspace_session_created_idx").on(table.workspaceId, table.sessionId, table.createdAt)
-}));
-var agentRunStates = pgTable("agent_run_states", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  sessionId: uuid("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  turnId: uuid("turn_id").references(() => sessionTurns.id, { onDelete: "set null" }),
-  stateVersion: integer("state_version").notNull(),
-  serializedRunState: text("serialized_run_state").notNull(),
-  pendingApprovals: jsonb("pending_approvals").$type().notNull().default([]),
-  // The Codex account that FROZE this run state: the turn's resolved codex
-  // credential id (pin > workspace-active), or NULL when frozen on the
-  // non-codex / Azure path (or before this column existed). The serialized
-  // RunState blob round-trips `reasoning.encrypted_content` minted by the
-  // ChatGPT/Codex backend — account/org-bound, so a foreign blob 400s — and the
-  // foreign reasoning ids the Responses backend validates; but the blob carries
-  // NO per-item producer tag (those live only on session_history_items). So we
-  // stamp the freezing account here: on a resume (approval decision, or the
-  // items-mode run-state fallback) whose codex account DIFFERS from this value,
-  // the replay path neutralizes every reasoning item's account-bound identity
-  // (encrypted_content + provider id) in the blob before it reaches the model.
-  // Deliberately NO FK: provenance must OUTLIVE the account's hard-disconnect (a
-  // stale-but-null tag still mismatches a live codex id, so the strip stays
-  // correct either way). NULL on both sides (non-codex freeze + non-codex
-  // resume) is a no-op, so single-account and non-codex sessions are unchanged.
-  frozenCodexCredentialId: uuid("frozen_codex_credential_id"),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-});
-var sessionHistoryItems = pgTable("session_history_items", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  sessionId: uuid("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  turnId: uuid("turn_id").references(() => sessionTurns.id, { onDelete: "set null" }),
-  // Numeric (not integer) so the synthetic compaction-summary row can be
-  // inserted at a FRACTIONAL position (boundaryPosition - 0.5) that sorts ahead
-  // of the kept tail without colliding with — and thus overwriting — the real
-  // prefix row at boundaryPosition - 1. Normally-appended rows keep whole-number
-  // positions; only the summary uses the half-step. `mode: "number"` maps the
-  // postgres.js string back to a JS number so every reader stays numeric.
-  position: numeric("position", { mode: "number" }).notNull(),
-  item: jsonb("item").$type().notNull(),
-  // Live-row flag for client-side context compaction. The read path selects
-  // only active rows; a compaction supersedes the summarized prefix (sets this
-  // false — never deletes, so the full transcript stays as an audit trail) and
-  // inserts ONE synthetic active summary row at the boundary. Defaults true so
-  // every existing and normally-appended row is live.
-  active: boolean("active").notNull().default(true),
-  // The Codex account that PRODUCED these items: the per-turn resolved codex
-  // credential id (pin > workspace-active), or NULL when produced on the
-  // non-codex / Azure path (or before this column existed). Used to strip
-  // cross-account `reasoning.encrypted_content` blobs — those are account/org-
-  // bound, minted by the ChatGPT/Codex backend, so replaying account A's blob
-  // into a turn running on account B 400s. The read path drops the encrypted
-  // reasoning of any item whose producer != the turn's current codex account.
-  // Deliberately NO FK: provenance must OUTLIVE the account's hard-disconnect
-  // (an ON DELETE SET NULL would erase the tag, and a stale-but-null tag still
-  // mismatches a live codex id so the strip stays correct either way).
-  producerCodexCredentialId: uuid("producer_codex_credential_id"),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  positionIdx: uniqueIndex("session_history_items_position_idx").on(table.workspaceId, table.sessionId, table.position)
-}));
-var sandboxSessionEnvelopes = pgTable("sandbox_session_envelopes", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  sessionId: uuid("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  envelope: jsonb("envelope").$type().notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  sessionIdx: uniqueIndex("sandbox_session_envelopes_session_idx").on(table.workspaceId, table.sessionId)
-}));
-var sandboxLeaseLivenessValues = ["cold", "warming", "warm", "draining"];
-var sandboxLeases = pgTable("sandbox_leases", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  sandboxGroupId: uuid("sandbox_group_id").notNull(),
-  liveness: text("liveness", { enum: sandboxLeaseLivenessValues }).notNull().default("cold"),
-  refcount: integer("refcount").notNull().default(0),
-  turnHolders: integer("turn_holders").notNull().default(0),
-  viewerHolders: integer("viewer_holders").notNull().default(0),
-  instanceId: text("instance_id"),
-  backend: text("backend").notNull(),
-  os: text("os").notNull().default("linux"),
-  // The container IMAGE the group box runs (Modal image ref / docker image). A shared
-  // box is SHARED STATE: all its sessions run the SAME filesystem, so they must run the
-  // same image. This column stamps the image the live box was created with; a resume
-  // whose resolved image DIFFERS is a conflict (B3): a solo holder recreates the box on
-  // the new image, N-holders are rejected (SandboxImageConflictError). Nullable — a
-  // legacy/cold row reads NULL = "image unknown", which never conflicts.
-  image: text("image"),
-  dataPlaneUrl: text("data_plane_url"),
-  // The REAL PTY terminal (ttyd pty-ws) rides a SEPARATE provider tunnel (7681)
-  // from the desktop noVNC (6080), so its resolved URL is cached independently.
-  // Recorded under the epoch fence by recordLeaseTerminalDataPlaneUrl; reset to
-  // null on every box re-key (warm-commit / fail / drain), symmetric with
-  // data_plane_url.
-  terminalDataPlaneUrl: text("terminal_data_plane_url"),
-  // integer (NOT bigint): the lease-epoch spike proved a raw int8 read returns a
-  // JS STRING from postgres-js, breaking the strict epoch-fence comparison (it
-  // was always-true → every turn fenced); int4 returns a JS number, the fix.
-  // Epochs never approach 2^31, so the narrower type loses nothing.
-  leaseEpoch: integer("lease_epoch").notNull().default(0),
-  // The group box-envelope (the "envelope split" Critical): the small recovery
-  // descriptor to resume()-by-id the group's box without a per-session join.
-  resumeBackendId: text("resume_backend_id"),
-  resumeState: jsonb("resume_state").$type(),
-  // Warm-time billing cursor: last_meter_at = accrual cursor; last_meter_tick =
-  // idempotency tick (warm_seconds accrued idempotent on
-  // (sandbox_group_id, lease_epoch, last_meter_tick) in P2.1).
-  lastMeterAt: timestamp("last_meter_at", { withTimezone: true }),
-  lastMeterTick: integer("last_meter_tick").notNull().default(0),
-  expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  groupIdx: uniqueIndex("sandbox_leases_group_idx").on(table.workspaceId, table.sandboxGroupId),
-  reaperIdx: index("sandbox_leases_reaper_idx").on(table.expiresAt).where(sql`${table.liveness} in ('warming','warm','draining')`)
-}));
-var sandboxLeaseHolders = pgTable("sandbox_lease_holders", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  leaseId: uuid("lease_id").notNull().references(() => sandboxLeases.id, { onDelete: "cascade" }),
-  kind: text("kind", { enum: ["turn", "viewer"] }).notNull(),
-  holderId: text("holder_id").notNull(),
-  // The attributing session within the (possibly shared) group.
-  subjectId: uuid("subject_id"),
-  lastHeartbeatAt: timestamp("last_heartbeat_at", { withTimezone: true }).notNull().defaultNow(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  holderIdx: uniqueIndex("sandbox_lease_holders_holder_idx").on(table.leaseId, table.kind, table.holderId),
-  staleIdx: index("sandbox_lease_holders_stale_idx").on(table.kind, table.lastHeartbeatAt),
-  leaseIdx: index("sandbox_lease_holders_lease_idx").on(table.leaseId)
-}));
-var sessionRecordingStateValues = ["recording", "finalizing", "available", "failed"];
-var sessionRecordingModeValues = ["manual", "on-turn", "on-verify"];
-var sessionRecordingCodecValues = ["h264-mp4", "vp9-webm"];
-var sessionRecordings = pgTable("session_recordings", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  sessionId: uuid("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  turnId: uuid("turn_id").references(() => sessionTurns.id, { onDelete: "set null" }),
-  state: text("state", { enum: sessionRecordingStateValues }).notNull(),
-  mode: text("mode", { enum: sessionRecordingModeValues }).notNull(),
-  codec: text("codec", { enum: sessionRecordingCodecValues }).notNull(),
-  storageKey: text("storage_key"),
-  sizeBytes: bigint("size_bytes", { mode: "number" }),
-  durationSeconds: numeric("duration_seconds").$type(),
-  width: integer("width").notNull(),
-  height: integer("height").notNull(),
-  reason: text("reason"),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  finalizedAt: timestamp("finalized_at", { withTimezone: true })
-}, (table) => ({
-  sessionIdx: index("session_recordings_session_idx").on(table.workspaceId, table.sessionId, table.createdAt)
-}));
-var sandboxPtySessions = pgTable("sandbox_pty_sessions", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  // == ptyId on the wire
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  sessionId: uuid("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  // The SDK numeric exec-session id used by writeStdin({ sessionId }). Null until
-  // the open exec yields a still-running process (a fast-exiting shell has none).
-  execSessionId: integer("exec_session_id"),
-  leaseEpoch: integer("lease_epoch").notNull(),
-  // fenced to the box that opened it
-  cols: integer("cols").notNull(),
-  rows: integer("rows").notNull(),
-  shell: text("shell").notNull(),
-  cwd: text("cwd").notNull(),
-  status: text("status").notNull().default("open"),
-  // 'open' | 'closed'
-  // The viewer grant/subject that opened it (free-text — access subjects are not
-  // always UUIDs, M5; so a text column, never a uuid NOT NULL).
-  openedBy: text("opened_by").notNull(),
-  lastInputAt: timestamp("last_input_at", { withTimezone: true }).notNull().defaultNow(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  closedAt: timestamp("closed_at", { withTimezone: true })
-}, (table) => ({
-  openIdx: index("sandbox_pty_sessions_session_idx").on(table.workspaceId, table.sessionId).where(sql`${table.status} = 'open'`)
-}));
-var enrollmentExposureValues = ["whole-machine"];
-var enrollmentStatusValues = ["active", "revoked"];
-var enrollmentOsValues = ["linux", "macos", "windows"];
-var sandboxKindValues = ["modal", "selfhosted"];
-var enrollments = pgTable("enrollments", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  // The agent's ed25519 public key (the machine identity).
-  pubkey: text("pubkey").notNull(),
-  exposure: text("exposure", { enum: enrollmentExposureValues }).notNull().default("whole-machine"),
-  hasDisplay: boolean("has_display").notNull().default(false),
-  // When the machine has a display it CANNOT capture (macOS Screen Recording / TCC
-  // not granted), the agent reports has_display=false AND a human, actionable reason
-  // here (e.g. "grant Screen Recording in System Settings"). NULL means capture is
-  // permitted (has_display=true) or the machine is genuinely headless — the reason
-  // distinguishes "display present but capture not granted" from plain "no display"
-  // so the Machines dashboard / VM picker can surface the specific hint. Refreshed
-  // from every connect Hello alongside has_display.
-  desktopUnavailableReason: text("desktop_unavailable_reason"),
-  allowScreenControl: boolean("allow_screen_control").notNull().default(false),
-  status: text("status", { enum: enrollmentStatusValues }).notNull().default("active"),
-  os: text("os", { enum: enrollmentOsValues }).notNull().default("linux"),
-  arch: text("arch").notNull().default("x86_64"),
-  // Heartbeat liveness cursor. Null until the first connect.
-  lastSeenAt: timestamp("last_seen_at", { withTimezone: true }),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  revokedAt: timestamp("revoked_at", { withTimezone: true }),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  // One enrollment per (workspace, pubkey): a re-enroll is an idempotent upsert.
-  workspacePubkey: uniqueIndex("enrollments_workspace_pubkey_idx").on(table.workspaceId, table.pubkey),
-  // List a workspace's ACTIVE machines without scanning revoked rows.
-  workspaceStatus: index("enrollments_workspace_status_idx").on(table.workspaceId, table.status)
-}));
-var deviceEnrollmentStatusValues = ["pending", "approved", "denied", "consumed"];
-var deviceEnrollmentRequests = pgTable("device_enrollment_requests", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  // The opaque code the agent polls with (unguessable, single-use). Unique.
-  deviceCode: text("device_code").notNull(),
-  // The short human-typed code (e.g. "WDJB-MJHT"). Unique among LIVE (pending)
-  // rows via a partial unique index so a recycled code never collides with a
-  // terminal row.
-  userCode: text("user_code").notNull(),
-  // The workspace this request was started for (resolved from the deployment-edge
-  // request context — the agent presents the access key, the flow binds to the
-  // single managed workspace OR a workspace hint). account_id rides along for RLS.
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  // The agent's ed25519 public key (the machine identity the enrollment binds to).
-  pubkey: text("pubkey").notNull(),
-  os: text("os", { enum: enrollmentOsValues }).notNull().default("linux"),
-  arch: text("arch").notNull().default("x86_64"),
-  machineName: text("machine_name"),
-  // The exposure the agent REQUESTED (whole-machine in v1; loudly consented at
-  // approve). Mirrors the enrollment column domain.
-  requestedExposure: text("requested_exposure", { enum: enrollmentExposureValues }).notNull().default("whole-machine"),
-  // The agent CAN offer a display (a real screen / Xvfb is available) — gates
-  // whether screen-control consent is even meaningful. has_display on the
-  // resulting enrollment is derived from this.
-  canOfferDisplay: boolean("can_offer_display").notNull().default(false),
-  // The agent REQUESTS screen control (computer-use). The user's allow_screen_control
-  // at approve is the AUTHORITATIVE consent; this is only the agent's request.
-  requestsScreenControl: boolean("requests_screen_control").notNull().default(false),
-  status: text("status", { enum: deviceEnrollmentStatusValues }).notNull().default("pending"),
-  // ── LOUD CONSENT capture (who/when/what), stamped at approve ──────────────
-  approvedBySubjectId: text("approved_by_subject_id"),
-  approvedBySubjectLabel: text("approved_by_subject_label"),
-  // The user's screen-control consent decision (whole-machine is mandatory at
-  // approve; screen-control is opt-in per this flag).
-  allowScreenControl: boolean("allow_screen_control").notNull().default(false),
-  approvedAt: timestamp("approved_at", { withTimezone: true }),
-  // The enrollment + sandbox the approve produced (acceptance #2: an enrollment
-  // row AND a sandbox row appear). Null until approved.
-  enrollmentId: uuid("enrollment_id").references(() => enrollments.id, { onDelete: "set null" }),
-  sandboxId: uuid("sandbox_id").references(() => sandboxes.id, { onDelete: "set null" }),
-  // The short-TTL expiry; a pending row past this is EXPIRED on poll.
-  expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  // The device_code is the agent's poll key — globally unique + indexed.
-  deviceCode: uniqueIndex("device_enrollment_requests_device_code_idx").on(table.deviceCode),
-  // The user_code must be unique among LIVE (pending) rows so the approve lookup
-  // is unambiguous; a terminal row's code may be recycled.
-  userCodePending: uniqueIndex("device_enrollment_requests_user_code_pending_idx").on(table.userCode).where(sql`${table.status} = 'pending'`),
-  workspaceCreated: index("device_enrollment_requests_workspace_created_idx").on(table.workspaceId, table.createdAt),
-  expires: index("device_enrollment_requests_expires_idx").on(table.expiresAt)
-}));
-var sandboxes = pgTable("sandboxes", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  kind: text("kind", { enum: sandboxKindValues }).notNull(),
-  name: text("name").notNull(),
-  enrollmentId: uuid("enrollment_id").references(() => enrollments.id, { onDelete: "set null" }),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  workspaceCreated: index("sandboxes_workspace_created_idx").on(table.workspaceId, table.createdAt),
-  enrollment: index("sandboxes_enrollment_idx").on(table.enrollmentId).where(sql`${table.enrollmentId} is not null`)
-}));
-var machineMetricsLatest = pgTable("machine_metrics_latest", {
-  enrollmentId: uuid("enrollment_id").primaryKey().references(() => enrollments.id, { onDelete: "cascade" }),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  cpuPercent: numeric("cpu_percent").$type(),
-  load1: numeric("load1").$type(),
-  load5: numeric("load5").$type(),
-  load15: numeric("load15").$type(),
-  memUsedBytes: bigint("mem_used_bytes", { mode: "number" }),
-  memTotalBytes: bigint("mem_total_bytes", { mode: "number" }),
-  diskUsedBytes: bigint("disk_used_bytes", { mode: "number" }),
-  diskTotalBytes: bigint("disk_total_bytes", { mode: "number" }),
-  gpuUtilPercent: numeric("gpu_util_percent").$type(),
-  gpuMemUsedBytes: bigint("gpu_mem_used_bytes", { mode: "number" }),
-  gpuMemTotalBytes: bigint("gpu_mem_total_bytes", { mode: "number" }),
-  contention: numeric("contention").$type(),
-  sampledAt: timestamp("sampled_at", { withTimezone: true }).notNull(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  workspace: index("machine_metrics_latest_workspace_idx").on(table.workspaceId)
-}));
-var machineMetricsSeries = pgTable("machine_metrics_series", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  enrollmentId: uuid("enrollment_id").notNull().references(() => enrollments.id, { onDelete: "cascade" }),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  cpuPercent: numeric("cpu_percent").$type(),
-  load1: numeric("load1").$type(),
-  load5: numeric("load5").$type(),
-  load15: numeric("load15").$type(),
-  memUsedBytes: bigint("mem_used_bytes", { mode: "number" }),
-  memTotalBytes: bigint("mem_total_bytes", { mode: "number" }),
-  diskUsedBytes: bigint("disk_used_bytes", { mode: "number" }),
-  diskTotalBytes: bigint("disk_total_bytes", { mode: "number" }),
-  gpuUtilPercent: numeric("gpu_util_percent").$type(),
-  gpuMemUsedBytes: bigint("gpu_mem_used_bytes", { mode: "number" }),
-  gpuMemTotalBytes: bigint("gpu_mem_total_bytes", { mode: "number" }),
-  contention: numeric("contention").$type(),
-  sampledAt: timestamp("sampled_at", { withTimezone: true }).notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  enrollmentSampled: index("machine_metrics_series_enrollment_sampled_idx").on(table.enrollmentId, table.sampledAt),
-  sampled: index("machine_metrics_series_sampled_idx").on(table.sampledAt)
-}));
-var scheduledTasks = pgTable("scheduled_tasks", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  name: text("name").notNull(),
-  status: text("status").notNull().default("active"),
-  schedule: jsonb("schedule").$type().notNull(),
-  temporalScheduleId: text("temporal_schedule_id").notNull(),
-  runMode: text("run_mode").notNull().default("new_session_per_run"),
-  overlapPolicy: text("overlap_policy").notNull().default("allow_concurrent"),
-  agentConfig: jsonb("agent_config").$type().notNull(),
-  reusableSessionId: uuid("reusable_session_id").references(() => sessions.id, { onDelete: "set null" }),
-  environmentId: uuid("environment_id").references(() => workspaceEnvironments.id, { onDelete: "restrict" }),
-  metadata: jsonb("metadata").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  temporalScheduleId: uniqueIndex("scheduled_tasks_workspace_temporal_schedule_id_idx").on(table.workspaceId, table.temporalScheduleId),
-  status: index("scheduled_tasks_workspace_status_idx").on(table.workspaceId, table.status),
-  environment: index("scheduled_tasks_environment_idx").on(table.workspaceId, table.environmentId)
-}));
-var scheduledTaskRuns = pgTable("scheduled_task_runs", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  taskId: uuid("task_id").notNull().references(() => scheduledTasks.id, { onDelete: "cascade" }),
-  status: text("status").notNull().default("queued"),
-  triggerType: text("trigger_type").notNull(),
-  scheduledAt: timestamp("scheduled_at", { withTimezone: true }),
-  firedAt: timestamp("fired_at", { withTimezone: true }).notNull().defaultNow(),
-  sessionId: uuid("session_id").references(() => sessions.id, { onDelete: "set null" }),
-  triggerEventId: uuid("trigger_event_id"),
-  error: text("error"),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  taskCreated: index("scheduled_task_runs_workspace_task_created_idx").on(table.workspaceId, table.taskId, table.createdAt),
-  session: index("scheduled_task_runs_workspace_session_idx").on(table.workspaceId, table.sessionId)
-}));
-var githubInstallations = pgTable("github_installations", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  installationId: integer("installation_id").notNull(),
-  accountLogin: text("account_login"),
-  accountType: text("account_type"),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  workspaceInstallation: uniqueIndex("github_installations_workspace_installation_idx").on(table.workspaceId, table.installationId),
-  installation: index("github_installations_installation_idx").on(table.installationId),
-  workspace: index("github_installations_workspace_idx").on(table.workspaceId)
-}));
-var usageEvents = pgTable("usage_events", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  subjectId: text("subject_id"),
-  eventType: text("event_type").notNull(),
-  quantity: bigint("quantity", { mode: "number" }).notNull(),
-  unit: text("unit").notNull(),
-  sourceResourceType: text("source_resource_type"),
-  sourceResourceId: text("source_resource_id"),
-  idempotencyKey: text("idempotency_key").notNull(),
-  occurredAt: timestamp("occurred_at", { withTimezone: true }).notNull(),
-  recordedAt: timestamp("recorded_at", { withTimezone: true }).notNull().defaultNow(),
-  exportedToBillingAt: timestamp("exported_to_billing_at", { withTimezone: true }),
-  billingProviderEventId: text("billing_provider_event_id")
-}, (table) => ({
-  idempotency: uniqueIndex("usage_events_idempotency_idx").on(table.idempotencyKey),
-  workspaceMetric: index("usage_events_workspace_metric_idx").on(table.workspaceId, table.eventType, table.occurredAt),
-  accountMetric: index("usage_events_account_metric_idx").on(table.accountId, table.eventType, table.occurredAt)
-}));
-var creditLedgerEntries = pgTable("credit_ledger_entries", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").references(() => workspaces.id, { onDelete: "set null" }),
-  type: text("type").notNull(),
-  amountMicros: bigint("amount_micros", { mode: "number" }).notNull(),
-  currency: text("currency").notNull().default("usd"),
-  sourceType: text("source_type"),
-  sourceId: text("source_id"),
-  idempotencyKey: text("idempotency_key").notNull(),
-  metadata: jsonb("metadata").$type().notNull().default({}),
-  occurredAt: timestamp("occurred_at", { withTimezone: true }).notNull().defaultNow(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  idempotency: uniqueIndex("credit_ledger_entries_idempotency_idx").on(table.idempotencyKey),
-  accountCreated: index("credit_ledger_entries_account_created_idx").on(table.accountId, table.createdAt)
-}));
-var billingCustomers = pgTable("billing_customers", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  provider: text("provider").notNull().default("stripe"),
-  providerCustomerId: text("provider_customer_id").notNull(),
-  email: text("email"),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  accountProvider: uniqueIndex("billing_customers_account_provider_idx").on(table.accountId, table.provider),
-  providerCustomer: uniqueIndex("billing_customers_provider_customer_idx").on(table.provider, table.providerCustomerId)
-}));
-var stripeWebhookEvents = pgTable("stripe_webhook_events", {
-  id: text("id").primaryKey(),
-  type: text("type").notNull(),
-  livemode: text("livemode").notNull().default("false"),
-  payload: jsonb("payload").$type().notNull(),
-  processedAt: timestamp("processed_at", { withTimezone: true }),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-});
-var auditEvents = pgTable("audit_events", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").references(() => managedAccounts.id, { onDelete: "set null" }),
-  workspaceId: uuid("workspace_id").references(() => workspaces.id, { onDelete: "set null" }),
-  subjectId: text("subject_id"),
-  action: text("action").notNull(),
-  targetType: text("target_type"),
-  targetId: text("target_id"),
-  metadata: jsonb("metadata").$type().notNull().default({}),
-  occurredAt: timestamp("occurred_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  accountCreated: index("audit_events_account_created_idx").on(table.accountId, table.occurredAt),
-  workspaceCreated: index("audit_events_workspace_created_idx").on(table.workspaceId, table.occurredAt)
-}));
-var packInstallations = pgTable("pack_installations", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  packId: text("pack_id").notNull(),
-  status: text("status").notNull().default("active"),
-  metadata: jsonb("metadata").$type().notNull().default({}),
-  enabledAt: timestamp("enabled_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  workspacePack: uniqueIndex("pack_installations_workspace_pack_idx").on(table.workspaceId, table.packId),
-  status: index("pack_installations_workspace_status_idx").on(table.workspaceId, table.status)
-}));
-var workspacePacks = pgTable("workspace_packs", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  packId: text("pack_id").notNull(),
-  manifest: jsonb("manifest").$type().notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  workspacePack: uniqueIndex("workspace_packs_workspace_pack_idx").on(table.workspaceId, table.packId)
-}));
-var importBatches = pgTable("import_batches", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  source: text("source").notNull(),
-  snapshotDate: timestamp("snapshot_date", { withTimezone: true }).notNull(),
-  snapshotRef: text("snapshot_ref"),
-  attributionNote: text("attribution_note").notNull(),
-  importedCount: integer("imported_count").notNull().default(0),
-  skippedCount: integer("skipped_count").notNull().default(0),
-  quarantinedCount: integer("quarantined_count").notNull().default(0),
-  logoFailureCount: integer("logo_failure_count").notNull().default(0),
-  staleCount: integer("stale_count").notNull().default(0),
-  details: jsonb("details").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  sourceSnapshot: index("import_batches_source_snapshot_idx").on(table.source, table.snapshotDate),
-  createdAt: index("import_batches_created_at_idx").on(table.createdAt)
-}));
-var capabilityCatalogItems = pgTable("capability_catalog_items", {
-  id: text("id").notNull(),
-  accountId: uuid("account_id").references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").references(() => workspaces.id, { onDelete: "cascade" }),
-  kind: text("kind").notNull(),
-  source: text("source").notNull().default("manual"),
-  name: text("name").notNull(),
-  description: text("description"),
-  category: text("category").notNull().default("custom"),
-  tags: jsonb("tags").$type().notNull().default([]),
-  homepageUrl: text("homepage_url"),
-  endpointUrl: text("endpoint_url"),
-  installUrl: text("install_url"),
-  authModel: text("auth_model"),
-  providerDomain: text("provider_domain"),
-  surfaceType: text("surface_type"),
-  transport: text("transport"),
-  mcpUrl: text("mcp_url"),
-  authKind: text("auth_kind"),
-  credentialFacts: jsonb("credential_facts").$type().notNull().default([]),
-  tier: text("tier"),
-  provenance: text("provenance"),
-  logoAssetPath: text("logo_asset_path"),
-  importBatchId: uuid("import_batch_id").references(() => importBatches.id, { onDelete: "set null" }),
-  stale: boolean("stale").notNull().default(false),
-  staleAt: timestamp("stale_at", { withTimezone: true }),
-  metadata: jsonb("metadata").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  workspaceCapability: uniqueIndex("capability_catalog_items_workspace_capability_idx").on(table.workspaceId, table.id),
-  registrySurface: uniqueIndex("capability_catalog_items_registry_surface_idx").on(table.source, table.providerDomain, table.mcpUrl),
-  globalCapability: uniqueIndex("capability_catalog_items_global_capability_idx").on(table.id).where(sql`${table.workspaceId} is null`),
-  kind: index("capability_catalog_items_workspace_kind_idx").on(table.workspaceId, table.kind),
-  category: index("capability_catalog_items_workspace_category_idx").on(table.workspaceId, table.category),
-  source: index("capability_catalog_items_workspace_source_idx").on(table.workspaceId, table.source),
-  providerDomain: index("capability_catalog_items_provider_domain_idx").on(table.providerDomain),
-  importBatch: index("capability_catalog_items_import_batch_idx").on(table.importBatchId),
-  stale: index("capability_catalog_items_source_stale_idx").on(table.source, table.stale)
-}));
-var capabilityInstallations = pgTable("capability_installations", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  capabilityId: text("capability_id").notNull(),
-  kind: text("kind").notNull(),
-  status: text("status").notNull().default("active"),
-  config: jsonb("config").$type().notNull().default({}),
-  metadata: jsonb("metadata").$type().notNull().default({}),
-  enabledAt: timestamp("enabled_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  workspaceCapability: uniqueIndex("capability_installations_workspace_capability_idx").on(table.workspaceId, table.capabilityId),
-  kind: index("capability_installations_workspace_kind_idx").on(table.workspaceId, table.kind),
-  status: index("capability_installations_workspace_status_idx").on(table.workspaceId, table.status)
-}));
-var socialConnections = pgTable("social_connections", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  provider: text("provider").notNull(),
-  accountHandle: text("account_handle").notNull(),
-  accountName: text("account_name"),
-  externalAccountId: text("external_account_id"),
-  status: text("status").notNull().default("connected"),
-  scopes: jsonb("scopes").$type().notNull().default([]),
-  credentialRef: text("credential_ref"),
-  tokenMetadata: jsonb("token_metadata").$type().notNull().default({}),
-  metadata: jsonb("metadata").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  workspaceProviderHandle: uniqueIndex("social_connections_workspace_provider_handle_idx").on(table.workspaceId, table.provider, table.accountHandle),
-  providerStatus: index("social_connections_workspace_provider_status_idx").on(table.workspaceId, table.provider, table.status)
-}));
-var socialPosts = pgTable("social_posts", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  accountId: uuid("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
-  workspaceId: uuid("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
-  connectionId: uuid("connection_id").notNull().references(() => socialConnections.id, { onDelete: "cascade" }),
-  provider: text("provider").notNull(),
-  externalPostId: text("external_post_id"),
-  url: text("url"),
-  authorHandle: text("author_handle"),
-  text: text("text").notNull(),
-  publishedAt: timestamp("published_at", { withTimezone: true }).notNull(),
-  metrics: jsonb("metrics").$type().notNull().default({}),
-  raw: jsonb("raw").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => ({
-  connectionExternalPost: uniqueIndex("social_posts_workspace_connection_external_post_idx").on(table.workspaceId, table.connectionId, table.externalPostId),
-  connectionPublished: index("social_posts_workspace_connection_published_idx").on(table.workspaceId, table.connectionId, table.publishedAt),
-  providerPublished: index("social_posts_workspace_provider_published_idx").on(table.workspaceId, table.provider, table.publishedAt)
-}));
-
-export {
-  managedAccounts,
-  workspaces,
-  workspaceMemberships,
-  apiKeys,
-  workspaceEnvironments,
-  workspaceEnvironmentVariables,
-  codexSubscriptionCredentials,
-  connections,
-  integrationOauthClients,
-  integrationOauthStateNonces,
-  codexRotationSettings,
-  sessions,
-  sessionMcpServers,
-  files,
-  fileUploads,
-  documentBases,
-  documents,
-  documentChunks,
-  knowledgeMemories,
-  sessionTurns,
-  sessionGoals,
-  sessionEvents,
-  agentRunStates,
-  sessionHistoryItems,
-  sandboxSessionEnvelopes,
-  sandboxLeaseLivenessValues,
-  sandboxLeases,
-  sandboxLeaseHolders,
-  sessionRecordingStateValues,
-  sessionRecordingModeValues,
-  sessionRecordingCodecValues,
-  sessionRecordings,
-  sandboxPtySessions,
-  enrollmentExposureValues,
-  enrollmentStatusValues,
-  enrollmentOsValues,
-  sandboxKindValues,
-  enrollments,
-  deviceEnrollmentStatusValues,
-  deviceEnrollmentRequests,
-  sandboxes,
-  machineMetricsLatest,
-  machineMetricsSeries,
-  scheduledTasks,
-  scheduledTaskRuns,
-  githubInstallations,
-  usageEvents,
-  creditLedgerEntries,
-  billingCustomers,
-  stripeWebhookEvents,
-  auditEvents,
-  packInstallations,
-  workspacePacks,
-  importBatches,
-  capabilityCatalogItems,
-  capabilityInstallations,
-  socialConnections,
-  socialPosts,
-  schema_exports
-};
-//# sourceMappingURL=chunk-ZIUCA2IO.js.map