@opengeni/db 0.14.0 → 0.16.2

package/dist/chunk-HZD7KVAR.js

@@ -0,0 +1,4648 @@
+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,
+  codexCapacityWaiters: () => codexCapacityWaiters,
+  codexCredentialLeases: () => codexCredentialLeases,
+  codexResetRedemptionAttempts: () => codexResetRedemptionAttempts,
+  codexRotationSettings: () => codexRotationSettings,
+  codexSubscriptionCredentials: () => codexSubscriptionCredentials,
+  composerDrafts: () => composerDrafts,
+  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,
+  githubInstallationRepositories: () => githubInstallationRepositories,
+  githubInstallations: () => githubInstallations,
+  hostExportConfig: () => hostExportConfig,
+  hostExportConsumers: () => hostExportConsumers,
+  hostExportCursorState: () => hostExportCursorState,
+  hostExportDeadLetters: () => hostExportDeadLetters,
+  hostExportOutbox: () => hostExportOutbox,
+  importBatches: () => importBatches,
+  integrationOauthClients: () => integrationOauthClients,
+  integrationOauthStateNonces: () => integrationOauthStateNonces,
+  knowledgeMemories: () => knowledgeMemories,
+  machineMetricsLatest: () => machineMetricsLatest,
+  machineMetricsSeries: () => machineMetricsSeries,
+  managedAccounts: () => managedAccounts,
+  modelCallFacts: () => modelCallFacts,
+  nestedAgentDepthConfiguration: () => nestedAgentDepthConfiguration,
+  newSessionDrafts: () => newSessionDrafts,
+  packInstallations: () => packInstallations,
+  preferenceRegistryEvents: () => preferenceRegistryEvents,
+  preferenceRegistryPreferences: () => preferenceRegistryPreferences,
+  preferenceRegistryRevisions: () => preferenceRegistryRevisions,
+  preferenceRegistrySnapshots: () => preferenceRegistrySnapshots,
+  rigChanges: () => rigChanges,
+  rigVersions: () => rigVersions,
+  rigs: () => rigs,
+  sandboxCheckpointArtifactStateValues: () => sandboxCheckpointArtifactStateValues,
+  sandboxCheckpointArtifacts: () => sandboxCheckpointArtifacts,
+  sandboxKindValues: () => sandboxKindValues,
+  sandboxLeaseHolders: () => sandboxLeaseHolders,
+  sandboxLeaseLivenessValues: () => sandboxLeaseLivenessValues,
+  sandboxLeases: () => sandboxLeases,
+  sandboxPtySessions: () => sandboxPtySessions,
+  sandboxRetainedProcessStateValues: () => sandboxRetainedProcessStateValues,
+  sandboxRetainedProcesses: () => sandboxRetainedProcesses,
+  sandboxSessionEnvelopes: () => sandboxSessionEnvelopes,
+  sandboxWorkspaceMutationActorKindValues: () => sandboxWorkspaceMutationActorKindValues,
+  sandboxWorkspaceMutationAdmissions: () => sandboxWorkspaceMutationAdmissions,
+  sandboxWorkspaceMutationHolderKindValues: () => sandboxWorkspaceMutationHolderKindValues,
+  sandboxes: () => sandboxes,
+  scheduledTaskRuns: () => scheduledTaskRuns,
+  scheduledTasks: () => scheduledTasks,
+  sessionAttemptInterruptions: () => sessionAttemptInterruptions,
+  sessionCommandReceipts: () => sessionCommandReceipts,
+  sessionEvents: () => sessionEvents,
+  sessionGoals: () => sessionGoals,
+  sessionHistoryItems: () => sessionHistoryItems,
+  sessionHumanInputRequests: () => sessionHumanInputRequests,
+  sessionListSnapshots: () => sessionListSnapshots,
+  sessionMcpServers: () => sessionMcpServers,
+  sessionPendingToolCalls: () => sessionPendingToolCalls,
+  sessionPins: () => sessionPins,
+  sessionRecordingCodecValues: () => sessionRecordingCodecValues,
+  sessionRecordingModeValues: () => sessionRecordingModeValues,
+  sessionRecordingStateValues: () => sessionRecordingStateValues,
+  sessionRecordings: () => sessionRecordings,
+  sessionSpawnDenials: () => sessionSpawnDenials,
+  sessionSystemUpdateOutbox: () => sessionSystemUpdateOutbox,
+  sessionSystemUpdates: () => sessionSystemUpdates,
+  sessionTurnAttempts: () => sessionTurnAttempts,
+  sessionTurns: () => sessionTurns,
+  sessionWorkflowWakeOutbox: () => sessionWorkflowWakeOutbox,
+  sessions: () => sessions,
+  slackBotDeleteOperations: () => slackBotDeleteOperations,
+  slackBotPostOperations: () => slackBotPostOperations,
+  socialConnections: () => socialConnections,
+  socialPosts: () => socialPosts,
+  stripeWebhookEvents: () => stripeWebhookEvents,
+  usageEvents: () => usageEvents,
+  workspaceCaptures: () => workspaceCaptures,
+  workspaceControlEvents: () => workspaceControlEvents,
+  workspaceInferenceControls: () => workspaceInferenceControls,
+  workspaceInstructionPolicyActivationEvents: () => workspaceInstructionPolicyActivationEvents,
+  workspaceInstructionPolicyHeads: () => workspaceInstructionPolicyHeads,
+  workspaceInstructionPolicyRevisions: () => workspaceInstructionPolicyRevisions,
+  workspaceMemberships: () => workspaceMemberships,
+  workspaceModelPolicies: () => workspaceModelPolicies,
+  workspacePacks: () => workspacePacks,
+  workspaceSessionActivityRevisions: () => workspaceSessionActivityRevisions,
+  workspaceVariableSetVariables: () => workspaceVariableSetVariables,
+  workspaceVariableSets: () => workspaceVariableSets,
+  workspaces: () => workspaces
+});
+import { sql as sql3 } from "drizzle-orm";
+import {
+  bigint as bigint3,
+  boolean as boolean2,
+  check as check3,
+  foreignKey,
+  index as index3,
+  integer as integer2,
+  jsonb as jsonb2,
+  numeric,
+  pgTable as pgTable3,
+  text as text3,
+  timestamp as timestamp3,
+  uniqueIndex as uniqueIndex3,
+  uuid as uuid3,
+  customType
+} from "drizzle-orm/pg-core";
+
+// src/workspace-instruction-policies-schema.ts
+import { sql } from "drizzle-orm";
+import {
+  bigint,
+  check,
+  index,
+  pgTable,
+  text,
+  timestamp,
+  uniqueIndex,
+  uuid
+} from "drizzle-orm/pg-core";
+var workspaceInstructionPolicyRevisions = pgTable(
+  "workspace_instruction_policy_revisions",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    accountId: uuid("account_id").notNull(),
+    workspaceId: uuid("workspace_id").notNull(),
+    revision: bigint("revision", { mode: "number" }).notNull().default(sql`nextval('workspace_instruction_policy_revision_seq')`),
+    kind: text("kind").notNull(),
+    scope: text("scope").notNull(),
+    roleKey: text("role_key"),
+    content: text("content").notNull(),
+    contentHash: text("content_hash").notNull(),
+    provenanceSource: text("provenance_source").notNull(),
+    provenanceSourceId: text("provenance_source_id"),
+    supersedesRevisionId: uuid("supersedes_revision_id"),
+    createdBySubjectId: text("created_by_subject_id").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceRevision: uniqueIndex(
+      "workspace_instruction_policy_revisions_workspace_revision_uq"
+    ).on(table.workspaceId, table.revision),
+    workspaceHistory: index("workspace_instruction_policy_revisions_workspace_history_idx").on(
+      table.workspaceId,
+      table.kind,
+      table.scope,
+      table.roleKey,
+      table.revision
+    ),
+    target: check(
+      "workspace_instruction_policy_revisions_target_chk",
+      sql`(
+        (${table.kind} = 'charter' and ${table.scope} = 'global' and ${table.roleKey} is null)
+        or (${table.kind} = 'policy' and ${table.scope} = 'global' and ${table.roleKey} is null)
+        or (${table.kind} = 'policy' and ${table.scope} = 'role' and ${table.roleKey} is not null)
+      )`
+    )
+  })
+);
+var workspaceInstructionPolicyHeads = pgTable(
+  "workspace_instruction_policy_heads",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    accountId: uuid("account_id").notNull(),
+    workspaceId: uuid("workspace_id").notNull(),
+    kind: text("kind").notNull(),
+    scope: text("scope").notNull(),
+    roleKey: text("role_key"),
+    revisionId: uuid("revision_id").notNull(),
+    revision: bigint("revision", { mode: "number" }).notNull(),
+    contentHash: text("content_hash").notNull(),
+    activationVersion: bigint("activation_version", { mode: "number" }).notNull(),
+    activatedAt: timestamp("activated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    charter: uniqueIndex("workspace_instruction_policy_heads_charter_uq").on(table.workspaceId).where(sql`${table.kind} = 'charter'`),
+    globalPolicy: uniqueIndex("workspace_instruction_policy_heads_global_policy_uq").on(table.workspaceId).where(sql`${table.kind} = 'policy' and ${table.scope} = 'global'`),
+    rolePolicy: uniqueIndex("workspace_instruction_policy_heads_role_policy_uq").on(table.workspaceId, table.roleKey).where(sql`${table.kind} = 'policy' and ${table.scope} = 'role'`),
+    target: check(
+      "workspace_instruction_policy_heads_target_chk",
+      sql`(
+        (${table.kind} = 'charter' and ${table.scope} = 'global' and ${table.roleKey} is null)
+        or (${table.kind} = 'policy' and ${table.scope} = 'global' and ${table.roleKey} is null)
+        or (${table.kind} = 'policy' and ${table.scope} = 'role' and ${table.roleKey} is not null)
+      )`
+    )
+  })
+);
+var workspaceInstructionPolicyActivationEvents = pgTable(
+  "workspace_instruction_policy_activation_events",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    accountId: uuid("account_id").notNull(),
+    workspaceId: uuid("workspace_id").notNull(),
+    kind: text("kind").notNull(),
+    scope: text("scope").notNull(),
+    roleKey: text("role_key"),
+    type: text("type").notNull(),
+    activationVersion: bigint("activation_version", { mode: "number" }).notNull(),
+    oldRevisionId: uuid("old_revision_id"),
+    oldRevision: bigint("old_revision", { mode: "number" }),
+    oldContentHash: text("old_content_hash"),
+    newRevisionId: uuid("new_revision_id").notNull(),
+    newRevision: bigint("new_revision", { mode: "number" }).notNull(),
+    newContentHash: text("new_content_hash").notNull(),
+    actorSubjectId: text("actor_subject_id").notNull(),
+    reason: text("reason").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceActivationVersion: uniqueIndex(
+      "workspace_instruction_policy_events_target_version_uq"
+    ).on(
+      table.workspaceId,
+      table.kind,
+      table.scope,
+      sql`coalesce(${table.roleKey}, '')`,
+      table.activationVersion
+    ),
+    workspaceTimeline: index("workspace_instruction_policy_events_workspace_time_idx").on(
+      table.workspaceId,
+      table.createdAt,
+      table.id
+    ),
+    target: check(
+      "workspace_instruction_policy_activation_events_target_chk",
+      sql`(
+        (${table.kind} = 'charter' and ${table.scope} = 'global' and ${table.roleKey} is null)
+        or (${table.kind} = 'policy' and ${table.scope} = 'global' and ${table.roleKey} is null)
+        or (${table.kind} = 'policy' and ${table.scope} = 'role' and ${table.roleKey} is not null)
+      )`
+    )
+  })
+);
+
+// src/preference-registry-schema.ts
+import { sql as sql2 } from "drizzle-orm";
+import {
+  bigint as bigint2,
+  boolean,
+  check as check2,
+  index as index2,
+  integer,
+  jsonb,
+  pgTable as pgTable2,
+  text as text2,
+  timestamp as timestamp2,
+  uniqueIndex as uniqueIndex2,
+  uuid as uuid2
+} from "drizzle-orm/pg-core";
+var preferenceRegistryPreferences = pgTable2(
+  "preference_registry_preferences",
+  {
+    id: uuid2("id").primaryKey().defaultRandom(),
+    accountId: uuid2("account_id").notNull(),
+    stableKey: text2("stable_key").notNull(),
+    scope: text2("scope").notNull(),
+    scopeWorkspaceId: uuid2("scope_workspace_id"),
+    scopeSubjectId: text2("scope_subject_id"),
+    status: text2("status").notNull().default("proposed"),
+    scopeVersion: integer("scope_version").notNull().default(1),
+    activationVersion: integer("activation_version").notNull().default(0),
+    activeRevisionId: uuid2("active_revision_id"),
+    activeRevision: bigint2("active_revision", { mode: "number" }),
+    activeContentHash: text2("active_content_hash"),
+    supersededByPreferenceId: uuid2("superseded_by_preference_id"),
+    createdBySubjectId: text2("created_by_subject_id").notNull(),
+    createdAt: timestamp2("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp2("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    organizationStableKey: uniqueIndex2("preference_registry_preferences_organization_key_uq").on(table.accountId, table.stableKey).where(sql2`${table.scope} = 'organization'`),
+    workspaceStableKey: uniqueIndex2("preference_registry_preferences_workspace_key_uq").on(table.accountId, table.scopeWorkspaceId, table.stableKey).where(sql2`${table.scope} = 'workspace'`),
+    userStableKey: uniqueIndex2("preference_registry_preferences_user_key_uq").on(table.accountId, table.scopeSubjectId, table.stableKey).where(sql2`${table.scope} = 'user'`),
+    applicable: index2("preference_registry_preferences_applicable_idx").on(
+      table.accountId,
+      table.scope,
+      table.scopeWorkspaceId,
+      table.scopeSubjectId,
+      table.status,
+      table.stableKey
+    ),
+    scopeShape: check2(
+      "preference_registry_preferences_scope_shape_chk",
+      sql2`(
+        (${table.scope} = 'organization' and ${table.scopeWorkspaceId} is null and ${table.scopeSubjectId} is null)
+        or (${table.scope} = 'workspace' and ${table.scopeWorkspaceId} is not null and ${table.scopeSubjectId} is null)
+        or (${table.scope} = 'user' and ${table.scopeWorkspaceId} is null and ${table.scopeSubjectId} is not null)
+      )`
+    )
+  })
+);
+var preferenceRegistryRevisions = pgTable2(
+  "preference_registry_revisions",
+  {
+    id: uuid2("id").primaryKey().defaultRandom(),
+    accountId: uuid2("account_id").notNull(),
+    preferenceId: uuid2("preference_id").notNull(),
+    revision: bigint2("revision", { mode: "number" }).notNull().default(sql2`nextval('preference_registry_revision_seq')`),
+    title: text2("title").notNull(),
+    description: text2("description").notNull(),
+    content: text2("content").notNull(),
+    contentHash: text2("content_hash").notNull(),
+    precedenceRank: integer("precedence_rank").notNull().default(0),
+    conflictStrategy: text2("conflict_strategy").notNull(),
+    conflictsWith: jsonb("conflicts_with").$type().notNull().default([]),
+    provenanceSource: text2("provenance_source").notNull(),
+    provenanceSourceId: text2("provenance_source_id"),
+    trust: text2("trust").notNull(),
+    expiresAt: timestamp2("expires_at", { withTimezone: true }),
+    correctsRevisionId: uuid2("corrects_revision_id"),
+    createdBySubjectId: text2("created_by_subject_id").notNull(),
+    createdAt: timestamp2("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    preferenceRevision: uniqueIndex2("preference_registry_revisions_preference_revision_uq").on(
+      table.preferenceId,
+      table.revision
+    ),
+    history: index2("preference_registry_revisions_history_idx").on(
+      table.preferenceId,
+      table.revision
+    )
+  })
+);
+var preferenceRegistryEvents = pgTable2(
+  "preference_registry_events",
+  {
+    id: uuid2("id").primaryKey().defaultRandom(),
+    accountId: uuid2("account_id").notNull(),
+    preferenceId: uuid2("preference_id").notNull(),
+    type: text2("type").notNull(),
+    version: integer("version").notNull(),
+    oldRevisionId: uuid2("old_revision_id"),
+    newRevisionId: uuid2("new_revision_id"),
+    oldScope: text2("old_scope"),
+    oldWorkspaceId: uuid2("old_workspace_id"),
+    oldSubjectId: text2("old_subject_id"),
+    newScope: text2("new_scope"),
+    newWorkspaceId: uuid2("new_workspace_id"),
+    newSubjectId: text2("new_subject_id"),
+    relatedPreferenceId: uuid2("related_preference_id"),
+    actorSubjectId: text2("actor_subject_id").notNull(),
+    reason: text2("reason").notNull(),
+    createdAt: timestamp2("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    preferenceVersion: uniqueIndex2("preference_registry_events_preference_version_uq").on(
+      table.preferenceId,
+      table.version
+    ),
+    timeline: index2("preference_registry_events_timeline_idx").on(
+      table.preferenceId,
+      table.createdAt,
+      table.id
+    )
+  })
+);
+var preferenceRegistrySnapshots = pgTable2(
+  "preference_registry_snapshots",
+  {
+    id: uuid2("id").primaryKey().defaultRandom(),
+    accountId: uuid2("account_id").notNull(),
+    workspaceId: uuid2("workspace_id").notNull(),
+    sessionId: uuid2("session_id").notNull(),
+    turnId: uuid2("turn_id").notNull(),
+    attemptId: uuid2("attempt_id").notNull(),
+    executionGeneration: integer("execution_generation").notNull(),
+    initiatingHumanSubjectId: text2("initiating_human_subject_id").notNull(),
+    descriptors: jsonb("descriptors").$type().notNull(),
+    descriptorHash: text2("descriptor_hash").notNull(),
+    truncated: boolean("truncated").notNull().default(false),
+    createdAt: timestamp2("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    attempt: uniqueIndex2("preference_registry_snapshots_attempt_uq").on(
+      table.accountId,
+      table.workspaceId,
+      table.attemptId
+    ),
+    humanTimeline: index2("preference_registry_snapshots_human_timeline_idx").on(
+      table.workspaceId,
+      table.initiatingHumanSubjectId,
+      table.createdAt
+    ),
+    descriptorBytes: check2(
+      "preference_registry_snapshots_descriptor_bytes_chk",
+      sql2`octet_length(convert_to(${table.descriptors}::text, 'UTF8')) <= 16384`
+    )
+  })
+);
+
+// src/schema.ts
+var vector = customType({
+  dataType() {
+    return "vector(3072)";
+  },
+  toDriver(value) {
+    return `[${value.join(",")}]`;
+  }
+});
+var managedAccounts = pgTable3(
+  "managed_accounts",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    name: text3("name").notNull(),
+    externalSource: text3("external_source"),
+    externalId: text3("external_id"),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    external: uniqueIndex3("managed_accounts_external_idx").on(
+      table.externalSource,
+      table.externalId
+    )
+  })
+);
+var workspaces = pgTable3(
+  "workspaces",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    name: text3("name").notNull(),
+    slug: text3("slug"),
+    externalSource: text3("external_source"),
+    externalId: text3("external_id"),
+    // White-label agent persona template override. NULL means the deployment
+    // default (OPENGENI_AGENT_INSTRUCTIONS_TEMPLATE / DEFAULT_AGENT_INSTRUCTIONS).
+    agentInstructions: text3("agent_instructions"),
+    // Growth-ready per-workspace settings bag (migration 0045). Holds memoryEnabled
+    // and future workspace-level toggles; validated/merged via WorkspaceSettingsSchema.
+    settings: jsonb2("settings").$type().notNull().default({}),
+    // The workspace's default rig (migration 0047). NULL ⇒ no default; sessions
+    // created without an explicit rig ride no rig (today's behavior exactly). FK
+    // (-> rigs(id) ON DELETE SET NULL) lives in migration 0047, not a Drizzle
+    // .references(), because `rigs` is declared later in this file (same
+    // forward-reference pattern as sessions.activeSandboxId). Consumed in M3.
+    defaultRigId: uuid3("default_rig_id"),
+    // Workspace-wide viewer admission intent set by the warm-meter reaper when
+    // managed credits or the monthly warm allowance are exhausted. It is
+    // deliberately independent of a lease so a dashboard cannot re-arm a
+    // draining box or spawn a cold successor before a fresh limit evaluation
+    // clears the gate.
+    sandboxViewerForceDrainReason: text3("sandbox_viewer_force_drain_reason", {
+      enum: ["balance", "warm_cap"]
+    }),
+    sandboxViewerForceDrainRequestedAt: timestamp3("sandbox_viewer_force_drain_requested_at", {
+      withTimezone: true
+    }),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    account: index3("workspaces_account_idx").on(table.accountId),
+    accountSlug: uniqueIndex3("workspaces_account_slug_idx").on(table.accountId, table.slug).where(sql3`${table.slug} is not null`),
+    external: uniqueIndex3("workspaces_external_idx").on(table.externalSource, table.externalId),
+    sandboxViewerForceDrain: index3("workspaces_sandbox_viewer_force_drain_idx").on(table.id).where(sql3`${table.sandboxViewerForceDrainReason} is not null`),
+    sandboxViewerForceDrainValid: check3(
+      "workspaces_sandbox_viewer_force_drain_check",
+      sql3`(
+          ${table.sandboxViewerForceDrainReason} is null
+          and ${table.sandboxViewerForceDrainRequestedAt} is null
+        ) or (
+          ${table.sandboxViewerForceDrainReason} in ('balance', 'warm_cap')
+          and ${table.sandboxViewerForceDrainRequestedAt} is not null
+        )`
+    )
+  })
+);
+var nestedAgentDepthConfiguration = pgTable3(
+  "nested_agent_depth_configuration",
+  {
+    singleton: boolean2("singleton").primaryKey().notNull().default(true),
+    maxNestedAgentDepth: integer2("max_nested_agent_depth").notNull(),
+    policySource: text3("policy_source").$type().notNull(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    singletonOnly: check3(
+      "nested_agent_depth_configuration_singleton_check",
+      sql3`${table.singleton}`
+    ),
+    maxValid: check3(
+      "nested_agent_depth_configuration_max_check",
+      sql3`${table.maxNestedAgentDepth} >= 0`
+    ),
+    sourceValid: check3(
+      "nested_agent_depth_configuration_source_check",
+      sql3`${table.policySource} in ('deployment', 'default')`
+    )
+  })
+);
+var workspaceInferenceControls = pgTable3(
+  "workspace_inference_controls",
+  {
+    workspaceId: uuid3("workspace_id").primaryKey(),
+    accountId: uuid3("account_id").notNull(),
+    revision: bigint3("revision", { mode: "number" }).notNull().default(0),
+    workspaceState: text3("workspace_state").notNull().default("active"),
+    workspacePauseRevision: bigint3("workspace_pause_revision", {
+      mode: "number"
+    }),
+    reason: text3("reason"),
+    changedBy: text3("changed_by"),
+    changedAt: timestamp3("changed_at", { withTimezone: true }),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceAccount: foreignKey({
+      name: "workspace_inference_controls_workspace_account_fk",
+      columns: [table.workspaceId, table.accountId],
+      foreignColumns: [workspaces.id, workspaces.accountId]
+    }).onDelete("cascade"),
+    workspaceAccountIdentity: uniqueIndex3("workspace_inference_controls_workspace_account_uq").on(
+      table.workspaceId,
+      table.accountId
+    ),
+    stateValid: check3(
+      "workspace_inference_controls_state_check",
+      sql3`${table.workspaceState} in ('active', 'paused')`
+    ),
+    pauseRevisionConsistent: check3(
+      "workspace_inference_controls_pause_revision_check",
+      sql3`(${table.workspaceState} = 'active' and ${table.workspacePauseRevision} is null)
+        or (${table.workspaceState} = 'paused' and ${table.workspacePauseRevision} is not null)`
+    ),
+    revisionValid: check3(
+      "workspace_inference_controls_revision_check",
+      sql3`${table.revision} >= 0 and (${table.workspacePauseRevision} is null or ${table.workspacePauseRevision} <= ${table.revision})`
+    )
+  })
+);
+var workspaceSessionActivityRevisions = pgTable3(
+  "workspace_session_activity_revisions",
+  {
+    workspaceId: uuid3("workspace_id").primaryKey(),
+    accountId: uuid3("account_id").notNull(),
+    revision: bigint3("revision", { mode: "number" }).notNull().default(0)
+  },
+  (table) => ({
+    workspaceAccount: foreignKey({
+      name: "workspace_session_activity_revisions_workspace_account_fk",
+      columns: [table.workspaceId, table.accountId],
+      foreignColumns: [workspaces.id, workspaces.accountId]
+    }).onDelete("cascade"),
+    revisionValid: check3(
+      "workspace_session_activity_revisions_revision_check",
+      sql3`${table.revision} >= 0`
+    )
+  })
+);
+var workspaceMemberships = pgTable3(
+  "workspace_memberships",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    subjectId: text3("subject_id").notNull(),
+    subjectLabel: text3("subject_label"),
+    role: text3("role").notNull().default("member"),
+    permissions: jsonb2("permissions").$type().notNull().default([]),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    subjectWorkspace: uniqueIndex3("workspace_memberships_subject_workspace_idx").on(
+      table.subjectId,
+      table.workspaceId
+    ),
+    subject: index3("workspace_memberships_subject_idx").on(table.subjectId),
+    account: index3("workspace_memberships_account_idx").on(table.accountId)
+  })
+);
+var apiKeys = pgTable3(
+  "api_keys",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").references(() => workspaces.id, {
+      onDelete: "cascade"
+    }),
+    name: text3("name").notNull(),
+    prefix: text3("prefix").notNull(),
+    keyHash: text3("key_hash").notNull(),
+    permissions: jsonb2("permissions").$type().notNull().default([]),
+    expiresAt: timestamp3("expires_at", { withTimezone: true }),
+    revokedAt: timestamp3("revoked_at", { withTimezone: true }),
+    lastUsedAt: timestamp3("last_used_at", { withTimezone: true }),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    prefix: index3("api_keys_prefix_idx").on(table.prefix),
+    hash: uniqueIndex3("api_keys_key_hash_idx").on(table.keyHash),
+    account: index3("api_keys_account_idx").on(table.accountId),
+    workspace: index3("api_keys_workspace_idx").on(table.workspaceId)
+  })
+);
+var workspaceVariableSets = pgTable3(
+  "workspace_variable_sets",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    name: text3("name").notNull(),
+    description: text3("description"),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceName: uniqueIndex3("workspace_variable_sets_workspace_name_idx").on(
+      table.workspaceId,
+      table.name
+    ),
+    workspaceCreated: index3("workspace_variable_sets_workspace_created_idx").on(
+      table.workspaceId,
+      table.createdAt
+    )
+  })
+);
+var workspaceVariableSetVariables = pgTable3(
+  "workspace_variable_set_variables",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    variableSetId: uuid3("variable_set_id").notNull().references(() => workspaceVariableSets.id, { onDelete: "cascade" }),
+    name: text3("name").notNull(),
+    // Format: v1:<base64 iv>:<base64 ciphertext||gcm-tag>. Never returned by any API.
+    valueEncrypted: text3("value_encrypted").notNull(),
+    version: integer2("version").notNull().default(1),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    variableSetName: uniqueIndex3("workspace_variable_set_variables_env_name_idx").on(
+      table.workspaceId,
+      table.variableSetId,
+      table.name
+    ),
+    variableSet: index3("workspace_variable_set_variables_workspace_env_idx").on(
+      table.workspaceId,
+      table.variableSetId
+    )
+  })
+);
+var codexSubscriptionCredentials = pgTable3(
+  "codex_subscription_credentials",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("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: text3("credential_encrypted").notNull(),
+    chatgptAccountId: text3("chatgpt_account_id"),
+    // plaintext ChatGPT-Account-ID header value (non-secret)
+    scopes: text3("scopes"),
+    // space-delimited, as granted
+    planType: text3("plan_type"),
+    isFedramp: boolean2("is_fedramp").notNull().default(false),
+    expiresAt: timestamp3("expires_at", { withTimezone: true }),
+    // derived from access-token JWT exp
+    lastRefreshAt: timestamp3("last_refresh_at", { withTimezone: true }),
+    status: text3("status").notNull().default("active"),
+    // active | needs_relogin | error
+    lastError: text3("last_error"),
+    version: integer2("version").notNull().default(1),
+    label: text3("label"),
+    // user-chosen nickname; null ⇒ derive from email/plan/account
+    accountEmail: text3("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: integer2("primary_used_percent"),
+    primaryResetAt: timestamp3("primary_reset_at", { withTimezone: true }),
+    secondaryUsedPercent: integer2("secondary_used_percent"),
+    secondaryResetAt: timestamp3("secondary_reset_at", { withTimezone: true }),
+    usageCheckedAt: timestamp3("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: timestamp3("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: text3("connector_namespaces").array(),
+    connectorsCheckedAt: timestamp3("connectors_checked_at", {
+      withTimezone: true
+    }),
+    // Workspace-local, server-held fairness cursor. Provider usage headers are
+    // capacity hints, never the sole allocator: live lease count is ranked first
+    // and this cursor deterministically breaks equal-load/equal-capacity ties.
+    // This flag controls NEW automatic allocations only. Credential health,
+    // refresh, encrypted material, and already-frozen/in-flight turns are
+    // intentionally independent. account eligibility policy owns toggle OCC/audit and product UI.
+    allocatorEnabled: boolean2("allocator_enabled").notNull().default(true),
+    // Independent OCC/audit sequence for the allocator toggle. Token refresh
+    // continues to own `version`; quota/cache writes own neither counter.
+    allocatorVersion: integer2("allocator_version").notNull().default(1),
+    allocatorUpdatedBySubjectId: text3("allocator_updated_by_subject_id"),
+    allocatorUpdatedAt: timestamp3("allocator_updated_at", { withTimezone: true }),
+    // Authoritative count-only summary cached from /wham/usage. Detailed rows
+    // are never persisted as redemption authority; every first POST preflights
+    // the provider's fresh detail endpoint.
+    resetCreditAvailableCount: integer2("reset_credit_available_count"),
+    resetCreditsCheckedAt: timestamp3("reset_credits_checked_at", { withTimezone: true }),
+    // Set only by a direct Better Auth cookie connection/reconnection. Legacy,
+    // configured, delegated, API-key, and agent-created rows remain view-only.
+    connectedBySubjectId: text3("connected_by_subject_id"),
+    selectionCount: integer2("selection_count").notNull().default(0),
+    lastSelectedAt: timestamp3("last_selected_at", { withTimezone: true }),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("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: uniqueIndex3("codex_subscription_credentials_ws_account_idx").on(table.workspaceId, table.chatgptAccountId).where(sql3`${table.chatgptAccountId} is not null`),
+    workspace: index3("codex_subscription_credentials_workspace_lookup_idx").on(table.workspaceId),
+    // Composite identity is the defense-in-depth FK target for workspace-local
+    // lease references in migration 0053.
+    workspaceIdentity: uniqueIndex3("codex_subscription_credentials_workspace_id_idx").on(
+      table.workspaceId,
+      table.id
+    )
+  })
+);
+var codexResetRedemptionAttempts = pgTable3(
+  "codex_reset_redemption_attempts",
+  {
+    id: uuid3("id").primaryKey(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    credentialId: uuid3("credential_id").notNull(),
+    subjectId: text3("subject_id").notNull(),
+    browserSessionHash: text3("browser_session_hash").notNull(),
+    creditId: text3("credit_id").notNull(),
+    upstreamIdempotencyKey: uuid3("upstream_idempotency_key").notNull().defaultRandom(),
+    status: text3("status").notNull().default("processing"),
+    outcome: text3("outcome"),
+    claimHolderId: uuid3("claim_holder_id"),
+    claimExpiresAt: timestamp3("claim_expires_at", { withTimezone: true }),
+    confirmationExpiresAt: timestamp3("confirmation_expires_at", { withTimezone: true }).notNull(),
+    providerStartedAt: timestamp3("provider_started_at", { withTimezone: true }),
+    completedAt: timestamp3("completed_at", { withTimezone: true }),
+    lastFailureKind: text3("last_failure_kind"),
+    retryCount: integer2("retry_count").notNull().default(0),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceAccount: foreignKey({
+      name: "codex_reset_redemption_workspace_account_fk",
+      columns: [table.workspaceId, table.accountId],
+      foreignColumns: [workspaces.id, workspaces.accountId]
+    }).onDelete("cascade"),
+    upstreamKey: uniqueIndex3("codex_reset_redemption_upstream_key_idx").on(
+      table.upstreamIdempotencyKey
+    ),
+    credentialCredit: uniqueIndex3("codex_reset_redemption_credential_credit_idx").on(table.workspaceId, table.credentialId, table.creditId).where(
+      sql3`${table.status} <> 'completed' or ${table.outcome} in ('reset', 'alreadyRedeemed')`
+    ),
+    workspaceCredential: index3("codex_reset_redemption_workspace_credential_idx").on(
+      table.workspaceId,
+      table.credentialId,
+      table.createdAt
+    ),
+    claimExpiry: index3("codex_reset_redemption_claim_expiry_idx").on(table.claimExpiresAt).where(sql3`${table.status} <> 'completed'`),
+    statusValid: check3(
+      "codex_reset_redemption_status_check",
+      sql3`${table.status} in ('processing', 'provider_started', 'completed')`
+    ),
+    outcomeValid: check3(
+      "codex_reset_redemption_outcome_check",
+      sql3`${table.outcome} is null or ${table.outcome} in ('reset', 'nothingToReset', 'noCredit', 'alreadyRedeemed')`
+    ),
+    completionConsistent: check3(
+      "codex_reset_redemption_completed_check",
+      sql3`(${table.status} = 'completed') = (${table.outcome} is not null and ${table.completedAt} is not null)`
+    ),
+    retryCountValid: check3(
+      "codex_reset_redemption_retry_count_check",
+      sql3`${table.retryCount} >= 0`
+    ),
+    humanSubjectValid: check3(
+      "codex_reset_redemption_human_subject_check",
+      sql3`${table.subjectId} like 'user:_%'`
+    )
+  })
+);
+var connections = pgTable3(
+  "connections",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    subjectId: text3("subject_id"),
+    providerDomain: text3("provider_domain").notNull(),
+    kind: text3("kind").notNull(),
+    status: text3("status").notNull().default("active"),
+    credentialEncrypted: text3("credential_encrypted").notNull(),
+    grantedScopes: jsonb2("granted_scopes").$type().notNull().default([]),
+    expiresAt: timestamp3("expires_at", { withTimezone: true }),
+    lastRefreshAt: timestamp3("last_refresh_at", { withTimezone: true }),
+    lastUsedAt: timestamp3("last_used_at", { withTimezone: true }),
+    lastError: text3("last_error"),
+    version: integer2("version").notNull().default(1),
+    // Server-owned proof that the dedicated install route verified the exact
+    // credential at this connection version. Generic/legacy writers cannot set
+    // these columns, and migration 0131 clears them when protected fields change
+    // without a fresh verification in the same statement.
+    verifiedInstallAt: timestamp3("verified_install_at", { withTimezone: true }),
+    verifiedInstallVersion: integer2("verified_install_version"),
+    metadata: jsonb2("metadata").$type().notNull().default({}),
+    createdBySubjectId: text3("created_by_subject_id"),
+    updatedBySubjectId: text3("updated_by_subject_id"),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceProviderStatus: index3("connections_workspace_provider_status_idx").on(
+      table.workspaceId,
+      table.providerDomain,
+      table.status
+    ),
+    workspaceSubjectProvider: index3("connections_workspace_subject_provider_idx").on(
+      table.workspaceId,
+      table.subjectId,
+      table.providerDomain
+    ),
+    workspaceKind: index3("connections_workspace_kind_idx").on(table.workspaceId, table.kind),
+    workspaceExpires: index3("connections_workspace_expires_idx").on(
+      table.workspaceId,
+      table.expiresAt
+    )
+  })
+);
+var slackBotPostOperations = pgTable3(
+  "slack_bot_post_operations",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    connectionId: uuid3("connection_id").notNull().references(() => connections.id, { onDelete: "cascade" }),
+    operationId: uuid3("operation_id").notNull(),
+    clientMessageId: uuid3("client_message_id").notNull(),
+    targetKind: text3("target_kind").$type().notNull(),
+    targetId: text3("target_id").notNull(),
+    requestDigest: text3("request_digest").notNull(),
+    status: text3("status").$type().notNull(),
+    claimHolderId: uuid3("claim_holder_id"),
+    claimExpiresAt: timestamp3("claim_expires_at", { withTimezone: true }),
+    attemptCount: integer2("attempt_count").notNull().default(0),
+    lastFailureCode: text3("last_failure_code"),
+    slackChannelId: text3("slack_channel_id"),
+    slackMessageTimestamp: text3("slack_message_timestamp"),
+    completedAt: timestamp3("completed_at", { withTimezone: true }),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceOperation: uniqueIndex3("slack_bot_post_operations_workspace_operation_uq").on(
+      table.workspaceId,
+      table.connectionId,
+      table.operationId
+    ),
+    workspaceStatus: index3("slack_bot_post_operations_workspace_status_idx").on(
+      table.workspaceId,
+      table.status,
+      table.updatedAt
+    ),
+    targetKindValid: check3(
+      "slack_bot_post_operations_target_kind_check",
+      sql3`${table.targetKind} in ('channel', 'user')`
+    ),
+    statusValid: check3(
+      "slack_bot_post_operations_status_check",
+      sql3`${table.status} in ('provider_started', 'completed')`
+    ),
+    identityValid: check3(
+      "slack_bot_post_operations_identity_check",
+      sql3`${table.clientMessageId} = ${table.operationId}
+        and length(${table.targetId}) between 1 and 64
+        and ${table.requestDigest} ~ '^[0-9a-f]{64}$'
+        and ${table.attemptCount} > 0
+        and ((${table.claimHolderId} is null) = (${table.claimExpiresAt} is null))`
+    ),
+    completionValid: check3(
+      "slack_bot_post_operations_completion_check",
+      sql3`(
+          ${table.status} = 'provider_started'
+          and ${table.slackChannelId} is null
+          and ${table.slackMessageTimestamp} is null
+          and ${table.completedAt} is null
+        ) or (
+          ${table.status} = 'completed'
+          and ${table.claimHolderId} is null
+          and ${table.claimExpiresAt} is null
+          and ${table.slackChannelId} is not null
+          and ${table.slackMessageTimestamp} is not null
+          and ${table.completedAt} is not null
+        )`
+    )
+  })
+);
+var slackBotDeleteOperations = pgTable3(
+  "slack_bot_delete_operations",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    connectionId: uuid3("connection_id").notNull().references(() => connections.id, { onDelete: "cascade" }),
+    operationId: uuid3("operation_id").notNull(),
+    principalType: text3("principal_type").$type().notNull(),
+    principalId: text3("principal_id").notNull(),
+    toolName: text3("tool_name").notNull(),
+    channelId: text3("channel_id").notNull(),
+    messageTimestamp: text3("message_timestamp").notNull(),
+    requestDigest: text3("request_digest").notNull(),
+    status: text3("status").$type().notNull(),
+    claimHolderId: uuid3("claim_holder_id"),
+    claimExpiresAt: timestamp3("claim_expires_at", { withTimezone: true }),
+    attemptCount: integer2("attempt_count").notNull().default(0),
+    lastFailureCode: text3("last_failure_code"),
+    slackChannelId: text3("slack_channel_id"),
+    slackMessageTimestamp: text3("slack_message_timestamp"),
+    completedAt: timestamp3("completed_at", { withTimezone: true }),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceOperation: uniqueIndex3("slack_bot_delete_operations_workspace_operation_uq").on(
+      table.workspaceId,
+      table.operationId
+    ),
+    workspaceStatus: index3("slack_bot_delete_operations_workspace_status_idx").on(
+      table.workspaceId,
+      table.status,
+      table.updatedAt
+    ),
+    principalValid: check3(
+      "slack_bot_delete_operations_principal_check",
+      sql3`${table.principalType} in ('subject', 'service')
+        and length(${table.principalId}) between 1 and 512`
+    ),
+    identityValid: check3(
+      "slack_bot_delete_operations_identity_check",
+      sql3`${table.toolName} = 'slack_bot_delete_message'
+        and length(${table.channelId}) between 1 and 64
+        and length(${table.messageTimestamp}) between 1 and 64
+        and ${table.requestDigest} ~ '^[0-9a-f]{64}$'
+        and ${table.attemptCount} > 0
+        and ((${table.claimHolderId} is null) = (${table.claimExpiresAt} is null))`
+    ),
+    statusValid: check3(
+      "slack_bot_delete_operations_status_check",
+      sql3`${table.status} in ('pending', 'provider_started', 'outcome_unknown', 'completed')`
+    ),
+    completionValid: check3(
+      "slack_bot_delete_operations_completion_check",
+      sql3`(
+          ${table.status} <> 'completed'
+          and ${table.slackChannelId} is null
+          and ${table.slackMessageTimestamp} is null
+          and ${table.completedAt} is null
+        ) or (
+          ${table.status} = 'completed'
+          and ${table.claimHolderId} is null
+          and ${table.claimExpiresAt} is null
+          and ${table.slackChannelId} is not null
+          and ${table.slackMessageTimestamp} is not null
+          and ${table.completedAt} is not null
+        )`
+    )
+  })
+);
+var integrationOauthClients = pgTable3(
+  "integration_oauth_clients",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    issuer: text3("issuer").notNull(),
+    authorizationServer: text3("authorization_server").notNull(),
+    clientId: text3("client_id").notNull(),
+    clientSecretEncrypted: text3("client_secret_encrypted"),
+    tokenEndpointAuthMethod: text3("token_endpoint_auth_method").notNull().default("none"),
+    metadata: jsonb2("metadata").$type().notNull().default({}),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    issuer: uniqueIndex3("integration_oauth_clients_issuer_idx").on(table.issuer),
+    authorizationServer: index3("integration_oauth_clients_as_idx").on(table.authorizationServer)
+  })
+);
+var integrationOauthStateNonces = pgTable3(
+  "integration_oauth_state_nonces",
+  {
+    nonce: text3("nonce").primaryKey(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    subjectId: text3("subject_id").notNull(),
+    expiresAt: timestamp3("expires_at", { withTimezone: true }).notNull(),
+    usedAt: timestamp3("used_at", { withTimezone: true }).notNull().defaultNow(),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspace: index3("integration_oauth_state_nonces_workspace_idx").on(table.workspaceId),
+    expires: index3("integration_oauth_state_nonces_expires_idx").on(table.expiresAt)
+  })
+);
+var codexRotationSettings = pgTable3(
+  "codex_rotation_settings",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    activeCredentialId: uuid3("active_credential_id"),
+    // Legacy selector bit. Keep false as the DB default forever: an old worker
+    // only understands this column, so a schema-first rollout or binary
+    // rollback must never make it enter the non-atomic rotation path.
+    rotationEnabled: boolean2("rotation_enabled").notNull().default(false),
+    // Revision-aware allocator cutover. Only migration-compatible API/worker
+    // code reads this bit; old binaries safely ignore it and keep the legacy
+    // pin/rotation policy.
+    leaseRotationEnabled: boolean2("lease_rotation_enabled").notNull().default(false),
+    rotationStrategy: text3("rotation_strategy").notNull().default("sharded"),
+    // sharded-rotation policy: legacy residue; behavior is always sharded
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspace: uniqueIndex3("codex_rotation_settings_workspace_idx").on(table.workspaceId)
+  })
+);
+var workspaceModelPolicies = pgTable3(
+  "workspace_model_policies",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    allowedProviders: text3("allowed_providers").array(),
+    allowedModels: text3("allowed_models").array(),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspace: uniqueIndex3("workspace_model_policies_workspace_idx").on(table.workspaceId)
+  })
+);
+var codexCredentialLeases = pgTable3(
+  "codex_credential_leases",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    credentialId: uuid3("credential_id").notNull(),
+    turnId: uuid3("turn_id").notNull(),
+    // Temporal activity execution fence. A successor dispatch for the same
+    // durable turn replaces holderId and increments generation atomically;
+    // stale/zombie heartbeats and releases must match both values.
+    holderId: text3("holder_id").notNull(),
+    generation: integer2("generation").notNull().default(1),
+    leasedUntil: timestamp3("leased_until", { withTimezone: true }).notNull(),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    turn: uniqueIndex3("codex_credential_leases_workspace_turn_idx").on(
+      table.workspaceId,
+      table.turnId
+    ),
+    activeCredential: index3("codex_credential_leases_active_credential_idx").on(
+      table.workspaceId,
+      table.credentialId,
+      table.leasedUntil
+    ),
+    expiry: index3("codex_credential_leases_expiry_idx").on(table.leasedUntil)
+  })
+);
+var sessions = pgTable3(
+  "sessions",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    status: text3("status").notNull().default("queued"),
+    initialMessage: text3("initial_message").notNull(),
+    // Invisible host context frozen with the winning session create. The
+    // initial turn copies this value so an idempotent repair can never adopt a
+    // retrying caller's different instructions.
+    initialTurnInstructions: text3("initial_turn_instructions"),
+    title: text3("title"),
+    titleSource: text3("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: text3("instructions"),
+    resources: jsonb2("resources").$type().notNull().default([]),
+    skills: jsonb2("skills").$type().notNull().default([]),
+    tools: jsonb2("tools").$type().notNull().default([]),
+    metadata: jsonb2("metadata").$type().notNull().default({}),
+    // Frozen creator fact. This is used for creation attribution and for the
+    // idempotent first-turn repair only; later turns capture their own actor.
+    createdByKind: text3("created_by_kind").notNull().default("service"),
+    createdBySubjectId: text3("created_by_subject_id").notNull().default("unattributed-legacy"),
+    createdByContext: jsonb2("created_by_context").$type().notNull().default({ backfill: true }),
+    model: text3("model").notNull(),
+    sandboxBackend: text3("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: text3("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: uuid3("sandbox_group_id").notNull(),
+    // The first-class swappable-sandbox POINTER (bring-your-own-compute M2).
+    // 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: uuid3("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: integer2("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: text3("working_dir"),
+    variableSetId: uuid3("variable_set_id").references(() => workspaceVariableSets.id, {
+      onDelete: "set null"
+    }),
+    // The rig this session rides + the exact rig version frozen at create time
+    // (migration 0047). NULL ⇒ the session rides no rig (today's behavior). FKs
+    // (-> rigs(id)/rig_versions(id) ON DELETE SET NULL) live in migration 0047,
+    // not Drizzle .references(), because those tables are declared later in this
+    // file (forward-reference pattern, same as activeSandboxId). Consumed in M3.
+    rigId: uuid3("rig_id"),
+    rigVersionId: uuid3("rig_version_id"),
+    // Non-default first-party MCP token permissions (manager-style sessions);
+    // null means the fixed worker default set in @opengeni/runtime.
+    firstPartyMcpPermissions: jsonb2("first_party_mcp_permissions").$type(),
+    // Exact model-visible first-party tool selection. All catalogued tools are
+    // selected by default; [] intentionally selects no broad-server tools.
+    firstPartyMcpTools: jsonb2("first_party_mcp_tools").$type().notNull(),
+    // Durable tool-policy origin. Migration 0136 removes the old null/legacy
+    // representation so every session has one explicit policy mode.
+    toolPolicy: jsonb2("tool_policy").$type().notNull(),
+    // Optimistic-concurrency fence for durable session tool-policy writes.
+    toolPolicyVersion: integer2("tool_policy_version").notNull().default(1),
+    // 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: uuid3("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: text3("create_idempotency_key"),
+    // Immutable creation-time hierarchy and policy snapshot. These values are
+    // populated by the database admission boundary and never re-derived from
+    // a live workspace setting for an existing session.
+    rootSessionId: uuid3("root_session_id").notNull(),
+    nestedAgentDepth: integer2("nested_agent_depth").notNull(),
+    maxNestedAgentDepthOverride: integer2("max_nested_agent_depth_override"),
+    effectiveMaxNestedAgentDepth: integer2("effective_max_nested_agent_depth").notNull(),
+    nestedAgentDepthPolicySource: text3("nested_agent_depth_policy_source").notNull(),
+    nestedAgentDepthPolicySessionId: uuid3("nested_agent_depth_policy_session_id"),
+    temporalWorkflowId: text3("temporal_workflow_id"),
+    activeTurnId: uuid3("active_turn_id"),
+    // Actual input tokens reported for the last model call of the most recent
+    // turn. The pre-turn portable 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: integer2("last_input_tokens"),
+    // Operator /compact request flag. 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: boolean2("compact_requested").notNull().default(false),
+    queueVersion: integer2("queue_version").notNull().default(0),
+    queueHeadPosition: bigint3("queue_head_position", { mode: "number" }).notNull().default(0),
+    queueTailPosition: bigint3("queue_tail_position", { mode: "number" }).notNull().default(0),
+    directControlState: text3("direct_control_state").notNull().default("active"),
+    directPauseRevision: bigint3("direct_pause_revision", { mode: "number" }),
+    subtreeRunOverrideRevision: bigint3("subtree_run_override_revision", {
+      mode: "number"
+    }),
+    controlVersion: bigint3("control_version", { mode: "number" }).notNull().default(0),
+    directControlReason: text3("direct_control_reason"),
+    directControlChangedBy: text3("direct_control_changed_by"),
+    directControlChangedAt: timestamp3("direct_control_changed_at", {
+      withTimezone: true
+    }),
+    lastSequence: integer2("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: uuid3("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: uuid3("codex_last_credential_id"),
+    // The SOURCE of codex_pinned_credential_id (AM-2): 'manual' — the user's
+    // in-session account switcher, which is SACRED and never moved by any policy —
+    // or 'policy' — the sharded rotation strategy's deterministic per-session home
+    // assignment, which MAY be re-sharded to another account when its own account
+    // caps. NULL when there is no pin (and for every pre-existing row). CHECK
+    // (manual|policy) lives in the migration; no FK (it describes the pin, not an
+    // account).
+    codexPinSource: text3("codex_pin_source"),
+    // Frozen at create: remote_v2 (Codex remote compaction + Codex-only models)
+    // or portable (plaintext compaction + free provider switching). Existing
+    // rows backfill to portable. CHECK lives in the migration.
+    codexCompactionMode: text3("codex_compaction_mode").notNull().default("portable"),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow(),
+    // Assigned by the database trigger whenever canonical updated_at activity
+    // advances. Legacy rows remain zero until touched; raw delta-only writers
+    // intentionally omit updated_at and therefore do not allocate revisions.
+    activityRevision: bigint3("activity_revision", { mode: "number" }).notNull().default(0)
+  },
+  (table) => ({
+    workspaceIdentity: uniqueIndex3("sessions_workspace_id_idx").on(table.workspaceId, table.id),
+    workspaceCreated: index3("sessions_workspace_created_idx").on(
+      table.workspaceId,
+      table.createdAt
+    ),
+    // Model-facing monitoring pages use exact (timestamp,id) keysets. Keep the
+    // older prefix index during rolling deploys; these composites serve both
+    // deterministic traversal and updatedAfter change scans.
+    workspaceCreatedId: index3("sessions_workspace_created_id_idx").on(
+      table.workspaceId,
+      table.createdAt.desc(),
+      table.id.desc()
+    ),
+    workspaceUpdatedId: index3("sessions_workspace_updated_id_idx").on(
+      table.workspaceId,
+      table.updatedAt.desc(),
+      table.id.desc()
+    ),
+    workspaceActivityRevision: index3("sessions_workspace_activity_revision_idx").on(
+      table.workspaceId,
+      table.activityRevision.desc(),
+      table.updatedAt.desc(),
+      table.id.desc()
+    ),
+    variableSet: index3("sessions_variable_set_idx").on(table.workspaceId, table.variableSetId),
+    parent: index3("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: index3("sessions_sandbox_group_idx").on(table.workspaceId, table.sandboxGroupId),
+    // Partial unique index: one session per (workspace, create_idempotency_key)
+    // when a key is present. The boundary trigger reserves the cross-outcome
+    // winner before this source row commits; a losing source insert is
+    // suppressed and the domain layer replays the durable winner.
+    createIdempotency: uniqueIndex3("sessions_workspace_create_idempotency_idx").on(table.workspaceId, table.createIdempotencyKey).where(sql3`${table.createIdempotencyKey} is not null`),
+    rootDepth: index3("sessions_workspace_root_depth_idx").on(
+      table.workspaceId,
+      table.rootSessionId,
+      table.nestedAgentDepth
+    )
+  })
+);
+var sessionSpawnDenials = pgTable3(
+  "session_spawn_denials",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull(),
+    workspaceId: uuid3("workspace_id").notNull(),
+    parentSessionId: uuid3("parent_session_id"),
+    rootSessionId: uuid3("root_session_id"),
+    currentDepth: integer2("current_depth").notNull(),
+    attemptedDepth: bigint3("attempted_depth", { mode: "number" }).notNull(),
+    effectiveMaxNestedAgentDepth: integer2("effective_max_nested_agent_depth").notNull(),
+    requestedMaxNestedAgentDepthOverride: integer2("requested_max_nested_agent_depth_override"),
+    policySource: text3("policy_source").notNull(),
+    policySessionId: uuid3("policy_session_id"),
+    subjectId: text3("subject_id"),
+    code: text3("code").notNull(),
+    idempotencyKey: text3("idempotency_key"),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceIdentity: uniqueIndex3("session_spawn_denials_workspace_id_uq").on(
+      table.workspaceId,
+      table.id
+    ),
+    workspaceCreated: index3("session_spawn_denials_workspace_created_idx").on(
+      table.workspaceId,
+      table.createdAt
+    ),
+    parent: index3("session_spawn_denials_parent_idx").on(
+      table.workspaceId,
+      table.parentSessionId,
+      table.createdAt
+    ),
+    idempotency: uniqueIndex3("session_spawn_denials_workspace_idempotency_idx").on(table.workspaceId, table.idempotencyKey).where(sql3`${table.idempotencyKey} is not null`),
+    workspaceAccount: foreignKey({
+      name: "session_spawn_denials_workspace_account_fk",
+      columns: [table.workspaceId, table.accountId],
+      foreignColumns: [workspaces.id, workspaces.accountId]
+    }).onDelete("cascade")
+  })
+);
+var sessionPins = pgTable3(
+  "session_pins",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    subjectId: text3("subject_id").notNull(),
+    sessionId: uuid3("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+    // Keep an unpinned tombstone (pinned=false, pinned_at=null) rather than
+    // deleting it. That preserves a monotonic version and prevents an ABA race:
+    // a stale client that saw pin version 1 cannot silently overwrite a later
+    // unpin+re-pin that would otherwise recreate version 1.
+    pinned: boolean2("pinned").notNull().default(true),
+    pinnedAt: timestamp3("pinned_at", { withTimezone: true }).defaultNow(),
+    version: integer2("version").notNull().default(1)
+  },
+  (table) => ({
+    subjectNonempty: check3(
+      "session_pins_subject_nonempty",
+      sql3`length(btrim(${table.subjectId})) > 0`
+    ),
+    versionPositive: check3("session_pins_version_positive", sql3`${table.version} >= 1`),
+    stateConsistent: check3(
+      "session_pins_state_consistent",
+      sql3`((${table.pinned}) and (${table.pinnedAt}) is not null) or ((not ${table.pinned}) and (${table.pinnedAt}) is null)`
+    ),
+    workspaceAccount: foreignKey({
+      name: "session_pins_workspace_account_fk",
+      columns: [table.workspaceId, table.accountId],
+      foreignColumns: [workspaces.id, workspaces.accountId]
+    }).onDelete("cascade"),
+    workspaceSession: foreignKey({
+      name: "session_pins_workspace_session_fk",
+      columns: [table.workspaceId, table.sessionId],
+      foreignColumns: [sessions.workspaceId, sessions.id]
+    }).onDelete("cascade"),
+    subjectSession: uniqueIndex3("session_pins_subject_workspace_session_idx").on(
+      table.subjectId,
+      table.workspaceId,
+      table.sessionId
+    ),
+    subjectPinned: index3("session_pins_workspace_subject_pinned_idx").on(
+      table.workspaceId,
+      table.subjectId,
+      table.pinned,
+      table.pinnedAt.desc(),
+      table.sessionId.desc()
+    )
+  })
+);
+var sessionListSnapshots = pgTable3(
+  "session_list_snapshots",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull(),
+    workspaceId: uuid3("workspace_id").notNull(),
+    subjectId: text3("subject_id").notNull(),
+    parentSessionFilter: text3("parent_session_filter").notNull().default("all"),
+    search: text3("search"),
+    ordinarySessionIds: uuid3("ordinary_session_ids").array().notNull().default(sql3`'{}'::uuid[]`),
+    expiresAt: timestamp3("expires_at", { withTimezone: true }).notNull(),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceAccount: foreignKey({
+      name: "session_list_snapshots_workspace_account_fk",
+      columns: [table.workspaceId, table.accountId],
+      foreignColumns: [workspaces.id, workspaces.accountId]
+    }).onDelete("cascade"),
+    subjectNonempty: check3(
+      "session_list_snapshots_subject_nonempty",
+      sql3`length(btrim(${table.subjectId})) > 0`
+    ),
+    parentFilterValid: check3(
+      "session_list_snapshots_parent_filter_valid",
+      sql3`${table.parentSessionFilter} = 'all' or ${table.parentSessionFilter} = 'null' or ${table.parentSessionFilter} ~ '^[0-9a-fA-F-]{36}$'`
+    ),
+    searchLength: check3(
+      "session_list_snapshots_search_length",
+      sql3`${table.search} is null or length(${table.search}) <= 200`
+    ),
+    workspaceExpiry: index3("session_list_snapshots_workspace_expiry_idx").on(
+      table.workspaceId,
+      table.subjectId,
+      table.expiresAt
+    ),
+    expiryReaper: index3("session_list_snapshots_expiry_reaper_idx").on(table.expiresAt, table.id)
+  })
+);
+var sessionMcpServers = pgTable3(
+  "session_mcp_servers",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    sessionId: uuid3("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+    serverId: text3("server_id").notNull(),
+    name: text3("name"),
+    url: text3("url").notNull(),
+    allowedTools: jsonb2("allowed_tools").$type(),
+    timeoutMs: integer2("timeout_ms"),
+    cacheToolsList: boolean2("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: jsonb2("require_approval").$type(),
+    // Non-secret pointer resolved at request time by the standalone broker or
+    // an embedding host. Unlike headersEncrypted, this is safe to project.
+    connectionRef: jsonb2("connection_ref").$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: jsonb2("headers_encrypted").$type().notNull().default({}),
+    credentialVersion: integer2("credential_version").notNull().default(1),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    sessionServer: uniqueIndex3("session_mcp_servers_session_server_idx").on(
+      table.workspaceId,
+      table.sessionId,
+      table.serverId
+    ),
+    session: index3("session_mcp_servers_session_idx").on(table.workspaceId, table.sessionId)
+  })
+);
+var files = pgTable3(
+  "files",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    status: text3("status").notNull().default("pending_upload"),
+    filename: text3("filename").notNull(),
+    safeFilename: text3("safe_filename").notNull(),
+    contentType: text3("content_type").notNull(),
+    sizeBytes: bigint3("size_bytes", { mode: "number" }).notNull(),
+    sha256: text3("sha256"),
+    bucket: text3("bucket").notNull(),
+    objectKey: text3("object_key").notNull(),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceCreated: index3("files_workspace_created_idx").on(table.workspaceId, table.createdAt),
+    objectKey: uniqueIndex3("files_object_key_idx").on(table.objectKey),
+    status: index3("files_status_idx").on(table.status)
+  })
+);
+var fileUploads = pgTable3(
+  "file_uploads",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    fileId: uuid3("file_id").notNull().references(() => files.id, { onDelete: "cascade" }),
+    status: text3("status").notNull().default("pending"),
+    expiresAt: timestamp3("expires_at", { withTimezone: true }).notNull(),
+    completedAt: timestamp3("completed_at", { withTimezone: true }),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspace: index3("file_uploads_workspace_idx").on(table.workspaceId),
+    fileId: index3("file_uploads_file_id_idx").on(table.fileId),
+    status: index3("file_uploads_status_idx").on(table.status)
+  })
+);
+var documentBases = pgTable3(
+  "document_bases",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    name: text3("name").notNull(),
+    description: text3("description"),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceCreated: index3("document_bases_workspace_created_idx").on(
+      table.workspaceId,
+      table.createdAt
+    ),
+    defaultName: uniqueIndex3("document_bases_workspace_default_name_uq").on(table.workspaceId).where(sql3`lower(btrim(${table.name})) = 'default'`)
+  })
+);
+var documents = pgTable3(
+  "documents",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    baseId: uuid3("base_id").notNull().references(() => documentBases.id, { onDelete: "cascade" }),
+    fileId: uuid3("file_id").notNull().references(() => files.id, { onDelete: "restrict" }),
+    status: text3("status").notNull().default("queued"),
+    title: text3("title").notNull(),
+    parser: text3("parser").notNull().default("liteparse"),
+    chunkCount: integer2("chunk_count").notNull().default(0),
+    error: text3("error"),
+    sourceKind: text3("source_kind").notNull().default("manual_upload"),
+    sourceUri: text3("source_uri"),
+    sourceExternalId: text3("source_external_id"),
+    sourceTitle: text3("source_title"),
+    sourceAuthor: text3("source_author"),
+    sourceCreatedAt: timestamp3("source_created_at", { withTimezone: true }),
+    sourceUpdatedAt: timestamp3("source_updated_at", { withTimezone: true }),
+    sourceVersion: text3("source_version"),
+    aclTags: jsonb2("acl_tags").$type().notNull().default([]),
+    // Per-document access controls. visibility 'private' restricts human reads to
+    // created_by (a grant subject id, not a uuid); agent_access=false hides the
+    // document from agent retrieval surfaces (docs MCP) while humans keep REST.
+    visibility: text3("visibility").notNull().default("workspace"),
+    createdBy: text3("created_by"),
+    agentAccess: boolean2("agent_access").notNull().default(true),
+    // Auto-curation output (knowledge drops).
+    summary: text3("summary"),
+    topics: jsonb2("topics").$type().notNull().default([]),
+    curationStatus: text3("curation_status").notNull().default("none"),
+    curation: jsonb2("curation").$type(),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    baseFile: uniqueIndex3("documents_workspace_base_file_idx").on(
+      table.workspaceId,
+      table.baseId,
+      table.fileId
+    ),
+    baseStatus: index3("documents_workspace_base_status_idx").on(
+      table.workspaceId,
+      table.baseId,
+      table.status
+    ),
+    sourceKind: index3("documents_workspace_source_kind_idx").on(
+      table.workspaceId,
+      table.sourceKind
+    ),
+    sourceExternalId: index3("documents_workspace_source_external_id_idx").on(
+      table.workspaceId,
+      table.sourceExternalId
+    ),
+    curationStatus: index3("documents_workspace_curation_status_idx").on(
+      table.workspaceId,
+      table.curationStatus
+    ),
+    visibilityState: check3(
+      "documents_visibility_chk",
+      sql3`${table.visibility} in ('workspace', 'private')`
+    ),
+    curationState: check3(
+      "documents_curation_status_chk",
+      sql3`${table.curationStatus} in ('none', 'pending', 'suggested', 'auto_filed', 'failed')`
+    ),
+    privateCreator: check3(
+      "documents_private_creator_chk",
+      sql3`${table.visibility} <> 'private' or nullif(btrim(${table.createdBy}), '') is not null`
+    ),
+    topicsArray: check3("documents_topics_array_chk", sql3`jsonb_typeof(${table.topics}) = 'array'`),
+    curationObject: check3(
+      "documents_curation_object_chk",
+      sql3`${table.curation} is null or jsonb_typeof(${table.curation}) = 'object'`
+    )
+  })
+);
+var documentChunks = pgTable3(
+  "document_chunks",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    documentId: uuid3("document_id").notNull().references(() => documents.id, { onDelete: "cascade" }),
+    baseId: uuid3("base_id").notNull().references(() => documentBases.id, { onDelete: "cascade" }),
+    fileId: uuid3("file_id").notNull().references(() => files.id, { onDelete: "restrict" }),
+    chunkIndex: integer2("chunk_index").notNull(),
+    text: text3("text").notNull(),
+    metadata: jsonb2("metadata").$type().notNull().default({}),
+    embedding: vector("embedding").notNull(),
+    embeddingModel: text3("embedding_model").notNull(),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    documentIndex: uniqueIndex3("document_chunks_workspace_document_index_idx").on(
+      table.workspaceId,
+      table.documentId,
+      table.chunkIndex
+    ),
+    base: index3("document_chunks_workspace_base_idx").on(table.workspaceId, table.baseId)
+  })
+);
+var knowledgeMemories = pgTable3(
+  "knowledge_memories",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    status: text3("status").notNull().default("proposed"),
+    kind: text3("kind").notNull().default("semantic"),
+    scope: text3("scope").notNull().default("workspace"),
+    text: text3("text").notNull(),
+    sourceRefs: jsonb2("source_refs").$type().notNull().default([]),
+    confidence: integer2("confidence").notNull().default(50),
+    metadata: jsonb2("metadata").$type().notNull().default({}),
+    createdBySessionId: uuid3("created_by_session_id").references(() => sessions.id, {
+      onDelete: "set null"
+    }),
+    reviewedBy: text3("reviewed_by"),
+    reviewedAt: timestamp3("reviewed_at", { withTimezone: true }),
+    // Workspace Memory V1 (migration 0045). Embedding is nullable: fail-soft writes
+    // (embedder unavailable) persist keyword-searchable rows without a vector.
+    embedding: vector("embedding"),
+    embeddingModel: text3("embedding_model"),
+    pinned: boolean2("pinned").notNull().default(false),
+    usageCount: integer2("usage_count").notNull().default(0),
+    lastUsedAt: timestamp3("last_used_at", { withTimezone: true }),
+    // Self-referential supersession chain. FKs live in migration 0045 (ON DELETE SET
+    // NULL); declared here as plain columns like the migration-only composite FK.
+    supersedesId: uuid3("supersedes_id"),
+    supersededById: uuid3("superseded_by_id"),
+    validFrom: timestamp3("valid_from", { withTimezone: true }).notNull().defaultNow(),
+    validUntil: timestamp3("valid_until", { withTimezone: true }),
+    // sha256(normalizeMemoryText(text)) — exact-dedup key; see memory-domain.
+    textHash: text3("text_hash"),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceStatus: index3("knowledge_memories_workspace_status_idx").on(
+      table.workspaceId,
+      table.status,
+      table.updatedAt
+    ),
+    workspaceKind: index3("knowledge_memories_workspace_kind_idx").on(table.workspaceId, table.kind),
+    workspaceScope: index3("knowledge_memories_workspace_scope_idx").on(
+      table.workspaceId,
+      table.scope
+    ),
+    createdBySession: index3("knowledge_memories_workspace_created_by_session_idx").on(
+      table.workspaceId,
+      table.createdBySessionId
+    ),
+    // Working-set selection (partial index mirrors migration 0045).
+    workspaceVisible: index3("knowledge_memories_workspace_visible_idx").on(table.workspaceId, table.pinned, table.updatedAt).where(sql3`${table.status} in ('active', 'approved')`),
+    workspaceTextHash: index3("knowledge_memories_workspace_text_hash_idx").on(
+      table.workspaceId,
+      table.textHash
+    ),
+    workspaceVisibleTextHashUnique: uniqueIndex3("knowledge_memories_workspace_visible_text_hash_uq").on(table.workspaceId, table.textHash).where(sql3`${table.status} in ('active', 'approved') and ${table.textHash} is not null`)
+  })
+);
+var sessionTurns = pgTable3(
+  "session_turns",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    sessionId: uuid3("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+    triggerEventId: uuid3("trigger_event_id").notNull(),
+    temporalWorkflowId: text3("temporal_workflow_id").notNull(),
+    status: text3("status").notNull(),
+    source: text3("source").notNull().default("user"),
+    position: bigint3("position", { mode: "number" }).notNull(),
+    prompt: text3("prompt").notNull(),
+    // Host context for this exact turn. System-level at runtime and deliberately
+    // separate from the visible prompt/event payload.
+    turnInstructions: text3("turn_instructions"),
+    resources: jsonb2("resources").$type().notNull().default([]),
+    tools: jsonb2("tools").$type().notNull().default([]),
+    // false = inherit the durable session policy; true = this turn explicitly
+    // replaces it with `tools` after the core subset fence.
+    toolsProvided: boolean2("tools_provided").notNull().default(false),
+    model: text3("model").notNull(),
+    reasoningEffort: text3("reasoning_effort").notNull(),
+    // Peer of model + reasoning_effort for Fast/priority inheritance.
+    latencyMode: text3("latency_mode").notNull().default("standard"),
+    sandboxBackend: text3("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: text3("sandbox_os"),
+    metadata: jsonb2("metadata").$type().notNull().default({}),
+    version: integer2("version").notNull().default(1),
+    executionGeneration: integer2("execution_generation").notNull().default(0),
+    // Composite FK to session_turn_attempts is installed by migration 0063.
+    // It lives in SQL because attempts carry the reciprocal turn FK and because
+    // the claim transaction preallocates this ID before inserting the attempt;
+    // the SQL constraint is therefore DEFERRABLE INITIALLY DEFERRED.
+    activeAttemptId: uuid3("active_attempt_id"),
+    lineage: jsonb2("lineage").$type().notNull().default({}),
+    // Required immutable authority captured when the turn is accepted. These
+    // columns are deliberately outside mutable metadata/lineage.
+    initiatorKind: text3("initiator_kind").notNull().default("service"),
+    initiatorSubjectId: text3("initiator_subject_id").notNull().default("unattributed-legacy"),
+    initiatorContext: jsonb2("initiator_context").$type().notNull().default({ backfill: true }),
+    cancelledBy: text3("cancelled_by"),
+    cancelReason: text3("cancel_reason"),
+    // 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: integer2("toolspace_call_count").notNull().default(0),
+    startedAt: timestamp3("started_at", { withTimezone: true }),
+    finishedAt: timestamp3("finished_at", { withTimezone: true }),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceIdentity: uniqueIndex3("session_turns_workspace_id_idx").on(
+      table.workspaceId,
+      table.id
+    ),
+    queue: index3("session_turns_workspace_queue_idx").on(
+      table.workspaceId,
+      table.sessionId,
+      table.status,
+      table.position
+    ),
+    oneCurrentInference: uniqueIndex3("session_turns_one_current_inference_uq").on(table.workspaceId, table.sessionId).where(sql3`${table.status} in ('running','requires_action','recovering','waiting_capacity')`),
+    latencyModeValid: check3(
+      "session_turns_latency_mode_check",
+      sql3`${table.latencyMode} in ('standard', 'priority', 'fast')`
+    )
+  })
+);
+var sessionTurnAttempts = pgTable3(
+  "session_turn_attempts",
+  {
+    id: uuid3("id").primaryKey(),
+    accountId: uuid3("account_id").notNull(),
+    workspaceId: uuid3("workspace_id").notNull(),
+    sessionId: uuid3("session_id").notNull(),
+    turnId: uuid3("turn_id").notNull(),
+    executionGeneration: integer2("execution_generation").notNull(),
+    state: text3("state").notNull().default("claimed"),
+    outcome: text3("outcome"),
+    temporalWorkflowId: text3("temporal_workflow_id").notNull(),
+    temporalWorkflowRunId: text3("temporal_workflow_run_id").notNull(),
+    temporalActivityId: text3("temporal_activity_id").notNull(),
+    workerId: text3("worker_id"),
+    leaseId: text3("lease_id"),
+    leaseExpiresAt: timestamp3("lease_expires_at", { withTimezone: true }),
+    verifiedControlRevision: bigint3("verified_control_revision", {
+      mode: "number"
+    }).notNull(),
+    // Immutable policy snapshot captured under the session lock at claim.
+    mcpApprovalPolicies: jsonb2("mcp_approval_policies").$type().notNull(),
+    startedAt: timestamp3("started_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow(),
+    closedAt: timestamp3("closed_at", { withTimezone: true }),
+    // The cancelled activity writes this after losing inference, user-visible
+    // output, and workspace-persistence authority. Fenced/idempotent cleanup
+    // and telemetry may still finish. Temporal activity cancellation or
+    // terminalization is transport state only; queue admission and clients use
+    // this durable receipt as the physical-quiescence authority.
+    quiescedAt: timestamp3("quiesced_at", { withTimezone: true })
+  },
+  (table) => ({
+    workspaceAccount: foreignKey({
+      name: "session_turn_attempts_workspace_account_fk",
+      columns: [table.workspaceId, table.accountId],
+      foreignColumns: [workspaces.id, workspaces.accountId]
+    }).onDelete("cascade"),
+    workspaceSession: foreignKey({
+      name: "session_turn_attempts_workspace_session_fk",
+      columns: [table.workspaceId, table.sessionId],
+      foreignColumns: [sessions.workspaceId, sessions.id]
+    }).onDelete("restrict"),
+    workspaceTurn: foreignKey({
+      name: "session_turn_attempts_workspace_turn_fk",
+      columns: [table.workspaceId, table.turnId],
+      foreignColumns: [sessionTurns.workspaceId, sessionTurns.id]
+    }).onDelete("restrict"),
+    workspaceIdentity: uniqueIndex3("session_turn_attempts_workspace_id_uq").on(
+      table.workspaceId,
+      table.id
+    ),
+    ownershipIdentity: uniqueIndex3("session_turn_attempts_human_input_owner_uq").on(
+      table.accountId,
+      table.workspaceId,
+      table.sessionId,
+      table.turnId,
+      table.id
+    ),
+    liveTurn: uniqueIndex3("session_turn_attempts_live_turn_uq").on(table.workspaceId, table.turnId).where(sql3`${table.state} in ('claimed', 'running')`),
+    liveSession: uniqueIndex3("session_turn_attempts_live_session_uq").on(table.workspaceId, table.sessionId).where(sql3`${table.state} in ('claimed', 'running')`),
+    latestSessionAttempt: index3("session_turn_attempts_latest_session_idx").on(
+      table.workspaceId,
+      table.sessionId,
+      table.startedAt.desc(),
+      table.id.desc()
+    ),
+    dispatch: uniqueIndex3("session_turn_attempts_dispatch_uq").on(
+      table.workspaceId,
+      table.temporalWorkflowRunId,
+      table.temporalActivityId
+    ),
+    leaseExpiry: index3("session_turn_attempts_lease_expiry_idx").on(table.leaseExpiresAt, table.workspaceId, table.sessionId).where(sql3`${table.state} in ('claimed', 'running')`),
+    stateValid: check3(
+      "session_turn_attempts_state_check",
+      sql3`${table.state} in ('claimed', 'running', 'closed')`
+    ),
+    outcomeValid: check3(
+      "session_turn_attempts_outcome_check",
+      sql3`${table.outcome} is null or ${table.outcome} in (
+        'completed', 'failed', 'cancelled', 'superseded', 'requires_action',
+        'waiting_capacity', 'interrupted_recoverable', 'lease_lost_recoverable',
+        'pre_cutover_closed'
+      )`
+    ),
+    closedConsistent: check3(
+      "session_turn_attempts_closed_check",
+      sql3`(${table.state} = 'closed' and ${table.outcome} is not null and ${table.closedAt} is not null)
+        or (${table.state} <> 'closed' and ${table.outcome} is null and ${table.closedAt} is null)`
+    )
+  })
+);
+var sessionCommandReceipts = pgTable3(
+  "session_command_receipts",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull(),
+    workspaceId: uuid3("workspace_id").notNull(),
+    actorType: text3("actor_type").notNull(),
+    actorSubjectId: text3("actor_subject_id"),
+    actorAttemptId: uuid3("actor_attempt_id"),
+    action: text3("action").notNull(),
+    targetSessionId: uuid3("target_session_id"),
+    targetTurnId: uuid3("target_turn_id"),
+    operationKey: text3("operation_key").notNull(),
+    canonicalRequestHash: text3("canonical_request_hash").notNull(),
+    appliedControlRevision: bigint3("applied_control_revision", {
+      mode: "number"
+    }),
+    appliedQueueVersion: integer2("applied_queue_version"),
+    appliedTurnVersion: integer2("applied_turn_version"),
+    appliedDraftRevision: bigint3("applied_draft_revision", { mode: "number" }),
+    result: jsonb2("result").$type().notNull().default({}),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceAccount: foreignKey({
+      name: "session_command_receipts_workspace_account_fk",
+      columns: [table.workspaceId, table.accountId],
+      foreignColumns: [workspaces.id, workspaces.accountId]
+    }).onDelete("cascade"),
+    actorAttempt: foreignKey({
+      name: "session_command_receipts_actor_attempt_fk",
+      columns: [table.workspaceId, table.actorAttemptId],
+      foreignColumns: [sessionTurnAttempts.workspaceId, sessionTurnAttempts.id]
+    }).onDelete("restrict"),
+    targetSession: foreignKey({
+      name: "session_command_receipts_target_session_fk",
+      columns: [table.workspaceId, table.targetSessionId],
+      foreignColumns: [sessions.workspaceId, sessions.id]
+    }).onDelete("restrict"),
+    targetTurn: foreignKey({
+      name: "session_command_receipts_target_turn_fk",
+      columns: [table.workspaceId, table.targetTurnId],
+      foreignColumns: [sessionTurns.workspaceId, sessionTurns.id]
+    }).onDelete("restrict"),
+    workspaceIdentity: uniqueIndex3("session_command_receipts_workspace_id_uq").on(
+      table.workspaceId,
+      table.id
+    ),
+    targetCreated: index3("session_command_receipts_target_created_idx").on(
+      table.workspaceId,
+      table.targetSessionId,
+      table.createdAt
+    ),
+    goalUpdateOperation: uniqueIndex3("session_command_receipts_goal_update_operation_uq").on(table.workspaceId, table.action, table.targetSessionId, table.operationKey).where(sql3`${table.action} = 'goal.update'`),
+    actorValid: check3(
+      "session_command_receipts_actor_check",
+      sql3`(
+        ${table.actorType} = 'agent_attempt'
+        and ${table.actorAttemptId} is not null
+        and ${table.actorSubjectId} is null
+      ) or (
+        ${table.actorType} in ('human', 'operator', 'service')
+        and ${table.actorSubjectId} is not null
+        and ${table.actorAttemptId} is null
+      )`
+    )
+  })
+);
+var workspaceControlEvents = pgTable3(
+  "workspace_control_events",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull(),
+    workspaceId: uuid3("workspace_id").notNull(),
+    revision: bigint3("revision", { mode: "number" }).notNull(),
+    scope: text3("scope").notNull(),
+    rootSessionId: uuid3("root_session_id"),
+    action: text3("action").notNull(),
+    automatic: boolean2("automatic").notNull().default(false),
+    reason: text3("reason"),
+    reasonOriginalBytes: integer2("reason_original_bytes"),
+    actor: text3("actor").notNull(),
+    // Null is the rolling-upgrade shape for untouched, already-bounded legacy
+    // rows. New writes and rewritten poison rows carry exact source byte facts.
+    actorOriginalBytes: integer2("actor_original_bytes"),
+    occurredAt: timestamp3("occurred_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceAccount: foreignKey({
+      name: "workspace_control_events_workspace_account_fk",
+      columns: [table.workspaceId, table.accountId],
+      foreignColumns: [workspaces.id, workspaces.accountId]
+    }).onDelete("cascade"),
+    rootSession: foreignKey({
+      name: "workspace_control_events_root_session_fk",
+      columns: [table.workspaceId, table.rootSessionId],
+      foreignColumns: [sessions.workspaceId, sessions.id]
+    }).onDelete("restrict"),
+    workspaceRevision: uniqueIndex3("workspace_control_events_workspace_revision_uq").on(
+      table.workspaceId,
+      table.revision
+    ),
+    revisionValid: check3("workspace_control_events_revision_check", sql3`${table.revision} > 0`),
+    shapeValid: check3(
+      "workspace_control_events_shape_check",
+      sql3`(${table.scope} = 'workspace' and ${table.rootSessionId} is null)
+        or (${table.scope} = 'session' and ${table.rootSessionId} is not null)`
+    ),
+    actionValid: check3(
+      "workspace_control_events_action_check",
+      sql3`${table.action} in ('pause', 'resume')`
+    )
+  })
+);
+var sessionAttemptInterruptions = pgTable3(
+  "session_attempt_interruptions",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull(),
+    workspaceId: uuid3("workspace_id").notNull(),
+    sessionId: uuid3("session_id").notNull(),
+    operationId: uuid3("operation_id").notNull(),
+    attemptId: uuid3("attempt_id").notNull(),
+    kind: text3("kind").notNull(),
+    controlRevision: bigint3("control_revision", { mode: "number" }).notNull(),
+    state: text3("state").notNull().default("pending"),
+    requestedAt: timestamp3("requested_at", { withTimezone: true }).notNull().defaultNow(),
+    deliveredAt: timestamp3("delivered_at", { withTimezone: true }),
+    acknowledgedAt: timestamp3("acknowledged_at", { withTimezone: true }),
+    settledAt: timestamp3("settled_at", { withTimezone: true })
+  },
+  (table) => ({
+    workspaceAccount: foreignKey({
+      name: "session_attempt_interruptions_workspace_account_fk",
+      columns: [table.workspaceId, table.accountId],
+      foreignColumns: [workspaces.id, workspaces.accountId]
+    }).onDelete("cascade"),
+    workspaceSession: foreignKey({
+      name: "session_attempt_interruptions_workspace_session_fk",
+      columns: [table.workspaceId, table.sessionId],
+      foreignColumns: [sessions.workspaceId, sessions.id]
+    }).onDelete("restrict"),
+    operation: foreignKey({
+      name: "session_attempt_interruptions_operation_fk",
+      columns: [table.workspaceId, table.operationId],
+      foreignColumns: [sessionCommandReceipts.workspaceId, sessionCommandReceipts.id]
+    }).onDelete("restrict"),
+    attempt: foreignKey({
+      name: "session_attempt_interruptions_attempt_fk",
+      columns: [table.workspaceId, table.attemptId],
+      foreignColumns: [sessionTurnAttempts.workspaceId, sessionTurnAttempts.id]
+    }).onDelete("restrict"),
+    operationAttempt: uniqueIndex3("session_attempt_interruptions_operation_attempt_uq").on(
+      table.operationId,
+      table.attemptId
+    ),
+    unsettled: index3("session_attempt_interruptions_unsettled_idx").on(table.workspaceId, table.sessionId, table.requestedAt).where(sql3`${table.state} in ('pending', 'delivered', 'acknowledged')`),
+    kindValid: check3(
+      "session_attempt_interruptions_kind_check",
+      sql3`${table.kind} in ('session_pause', 'workspace_pause', 'steer', 'maintenance')`
+    ),
+    stateValid: check3(
+      "session_attempt_interruptions_state_check",
+      sql3`${table.state} in ('pending', 'delivered', 'acknowledged', 'settled', 'rejected_stale')`
+    )
+  })
+);
+var composerDrafts = pgTable3(
+  "composer_drafts",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull(),
+    workspaceId: uuid3("workspace_id").notNull(),
+    sessionId: uuid3("session_id").notNull(),
+    subjectId: text3("subject_id").notNull(),
+    revision: bigint3("revision", { mode: "number" }).notNull().default(1),
+    text: text3("text").notNull().default(""),
+    resources: jsonb2("resources").$type().notNull().default([]),
+    tools: jsonb2("tools").$type().notNull().default([]),
+    toolsProvided: boolean2("tools_provided").notNull().default(false),
+    model: text3("model").notNull(),
+    reasoningEffort: text3("reasoning_effort").notNull(),
+    latencyMode: text3("latency_mode").notNull().default("standard"),
+    sourceTurnId: uuid3("source_turn_id"),
+    sourceTurnVersion: integer2("source_turn_version"),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceAccount: foreignKey({
+      name: "composer_drafts_workspace_account_fk",
+      columns: [table.workspaceId, table.accountId],
+      foreignColumns: [workspaces.id, workspaces.accountId]
+    }).onDelete("cascade"),
+    workspaceSession: foreignKey({
+      name: "composer_drafts_workspace_session_fk",
+      columns: [table.workspaceId, table.sessionId],
+      foreignColumns: [sessions.workspaceId, sessions.id]
+    }).onDelete("cascade"),
+    sourceTurn: foreignKey({
+      name: "composer_drafts_source_turn_fk",
+      columns: [table.workspaceId, table.sourceTurnId],
+      foreignColumns: [sessionTurns.workspaceId, sessionTurns.id]
+    }).onDelete("restrict"),
+    subjectSession: uniqueIndex3("composer_drafts_subject_session_uq").on(
+      table.workspaceId,
+      table.sessionId,
+      table.subjectId
+    ),
+    subjectValid: check3(
+      "composer_drafts_subject_check",
+      sql3`length(btrim(${table.subjectId})) > 0`
+    ),
+    revisionValid: check3("composer_drafts_revision_check", sql3`${table.revision} >= 1`),
+    latencyModeValid: check3(
+      "composer_drafts_latency_mode_check",
+      sql3`${table.latencyMode} in ('standard', 'priority', 'fast')`
+    )
+  })
+);
+var newSessionDrafts = pgTable3(
+  "new_session_drafts",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull(),
+    workspaceId: uuid3("workspace_id").notNull(),
+    subjectId: text3("subject_id").notNull(),
+    revision: bigint3("revision", { mode: "number" }).notNull().default(1),
+    text: text3("text").notNull().default(""),
+    resources: jsonb2("resources").$type().notNull().default([]),
+    tools: jsonb2("tools").$type().notNull().default([]),
+    model: text3("model").notNull(),
+    reasoningEffort: text3("reasoning_effort").notNull(),
+    latencyMode: text3("latency_mode").notNull().default("standard"),
+    sessionOptions: jsonb2("session_options").$type().notNull().default({}),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceAccount: foreignKey({
+      name: "new_session_drafts_workspace_account_fk",
+      columns: [table.workspaceId, table.accountId],
+      foreignColumns: [workspaces.id, workspaces.accountId]
+    }).onDelete("cascade"),
+    subjectWorkspace: uniqueIndex3("new_session_drafts_subject_workspace_uq").on(
+      table.workspaceId,
+      table.subjectId
+    ),
+    subjectValid: check3(
+      "new_session_drafts_subject_check",
+      sql3`length(btrim(${table.subjectId})) > 0`
+    ),
+    revisionValid: check3("new_session_drafts_revision_check", sql3`${table.revision} >= 1`),
+    latencyModeValid: check3(
+      "new_session_drafts_latency_mode_check",
+      sql3`${table.latencyMode} in ('standard', 'priority', 'fast')`
+    )
+  })
+);
+var sessionSystemUpdates = pgTable3(
+  "session_system_updates",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    sessionId: uuid3("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+    kind: text3("kind").notNull(),
+    classification: text3("classification").notNull().default("info"),
+    sourceId: text3("source_id").notNull(),
+    dedupeKey: text3("dedupe_key").notNull(),
+    summary: text3("summary").notNull(),
+    payload: jsonb2("payload").$type().notNull().default({}),
+    lineage: jsonb2("lineage").$type().notNull().default({}),
+    // pending is visible queue truth; delivered means its exact model-memory
+    // batch was durably claimed. Terminal cancellation/supersession is explicit.
+    state: text3("state").notNull().default("pending"),
+    deliveredTurnId: uuid3("delivered_turn_id").references(() => sessionTurns.id, {
+      onDelete: "set null"
+    }),
+    // Migration owns the forward FK to session_history_items, declared later.
+    // Every member of one claimed batch points at the exact model-memory row.
+    deliveredHistoryItemId: uuid3("delivered_history_item_id"),
+    deliveredAt: timestamp3("delivered_at", { withTimezone: true }),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    kindValid: check3(
+      "system_updates_kind_check",
+      sql3`${table.kind} in ('scheduled_occurrence', 'goal_continuation', 'agent_message', 'agent_steer_instruction', 'child_terminal_result')`
+    ),
+    payloadKindValid: check3(
+      "system_updates_payload_kind_check",
+      sql3`${table.payload} ->> 'type' = ${table.kind}`
+    ),
+    stateValid: check3(
+      "system_updates_state_check",
+      sql3`${table.state} in ('pending', 'delivered', 'cancelled', 'superseded', 'failed')`
+    ),
+    dedupe: uniqueIndex3("session_system_updates_dedupe_uq").on(
+      table.workspaceId,
+      table.sessionId,
+      table.dedupeKey
+    ),
+    pending: index3("session_system_updates_pending_idx").on(
+      table.workspaceId,
+      table.sessionId,
+      table.state,
+      table.createdAt
+    ),
+    onePendingSteer: uniqueIndex3("session_system_updates_one_pending_steer_idx").on(table.workspaceId, table.sessionId).where(sql3`${table.kind} = 'agent_steer_instruction' and ${table.state} = 'pending'`),
+    deliveryHistoryValid: check3(
+      "session_system_updates_delivery_history_check",
+      sql3`(
+        (${table.state} = 'delivered' and ${table.deliveredHistoryItemId} is not null)
+        or
+        (${table.state} <> 'delivered' and ${table.deliveredHistoryItemId} is null)
+      )`
+    )
+  })
+);
+var sessionSystemUpdateOutbox = pgTable3(
+  "session_system_update_outbox",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    sourceSessionId: uuid3("source_session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+    targetSessionId: uuid3("target_session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+    dedupeKey: text3("dedupe_key").notNull(),
+    kind: text3("kind").notNull(),
+    classification: text3("classification").notNull(),
+    sourceId: text3("source_id").notNull(),
+    summary: text3("summary").notNull(),
+    payload: jsonb2("payload").$type().notNull().default({}),
+    lineage: jsonb2("lineage").$type().notNull().default({}),
+    status: text3("status").notNull().default("pending"),
+    attempts: integer2("attempts").notNull().default(0),
+    updateId: uuid3("update_id"),
+    lastError: text3("last_error"),
+    deliveredAt: timestamp3("delivered_at", { withTimezone: true }),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    kindValid: check3(
+      "system_update_outbox_kind_check",
+      sql3`${table.kind} = 'child_terminal_result'`
+    ),
+    payloadKindValid: check3(
+      "system_update_outbox_payload_kind_check",
+      sql3`${table.payload} ->> 'type' = 'child_terminal_result'`
+    ),
+    dedupe: uniqueIndex3("session_system_update_outbox_dedupe_uq").on(
+      table.workspaceId,
+      table.dedupeKey
+    ),
+    pending: index3("session_system_update_outbox_pending_idx").on(table.status, table.createdAt)
+  })
+);
+var sessionWorkflowWakeOutbox = pgTable3(
+  "session_workflow_wake_outbox",
+  {
+    sessionId: uuid3("session_id").primaryKey(),
+    accountId: uuid3("account_id").notNull(),
+    workspaceId: uuid3("workspace_id").notNull(),
+    temporalWorkflowId: text3("temporal_workflow_id").notNull(),
+    wakeRevision: bigint3("wake_revision", { mode: "number" }).notNull().default(1),
+    deliveredRevision: bigint3("delivered_revision", { mode: "number" }).notNull().default(0),
+    reason: text3("reason").notNull(),
+    attempts: integer2("attempts").notNull().default(0),
+    nextAttemptAt: timestamp3("next_attempt_at", { withTimezone: true }).notNull().defaultNow(),
+    lastError: text3("last_error"),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    revisionValid: check3(
+      "session_workflow_wake_outbox_revision_check",
+      sql3`${table.wakeRevision} > 0 and ${table.deliveredRevision} >= 0 and ${table.deliveredRevision} <= ${table.wakeRevision}`
+    ),
+    revisionSafe: check3(
+      "session_workflow_wake_outbox_revision_safe_check",
+      sql3`${table.wakeRevision} <= 9007199254740991 and ${table.deliveredRevision} <= 9007199254740991`
+    ),
+    workspaceAccount: foreignKey({
+      name: "session_workflow_wake_outbox_workspace_account_fk",
+      columns: [table.workspaceId, table.accountId],
+      foreignColumns: [workspaces.id, workspaces.accountId]
+    }).onDelete("cascade"),
+    workspaceSessionFk: foreignKey({
+      name: "session_workflow_wake_outbox_workspace_session_fk",
+      columns: [table.workspaceId, table.sessionId],
+      foreignColumns: [sessions.workspaceId, sessions.id]
+    }).onDelete("cascade"),
+    workspaceSession: uniqueIndex3("session_workflow_wake_outbox_workspace_session_uq").on(
+      table.workspaceId,
+      table.sessionId
+    ),
+    pending: index3("session_workflow_wake_outbox_pending_idx").on(table.nextAttemptAt, table.updatedAt, table.sessionId).where(sql3`${table.wakeRevision} > ${table.deliveredRevision}`)
+  })
+);
+var sessionGoals = pgTable3(
+  "session_goals",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    sessionId: uuid3("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+    status: text3("status").notNull().default("active"),
+    // active | paused | completed
+    text: text3("text").notNull(),
+    successCriteria: text3("success_criteria"),
+    evidence: text3("evidence"),
+    // set by goal_complete
+    rationale: text3("rationale"),
+    // set by goal_pause
+    pausedReason: text3("paused_reason"),
+    // agent | user_pause | api | no_progress | max_auto_continuations | limits
+    createdBy: text3("created_by").notNull().default("api"),
+    // api | agent | scheduled_task
+    version: integer2("version").notNull().default(1),
+    // bumped on every set/update; progress signal
+    autoContinuations: integer2("auto_continuations").notNull().default(0),
+    noProgressStreak: integer2("no_progress_streak").notNull().default(0),
+    maxAutoContinuations: integer2("max_auto_continuations"),
+    // per-goal override; a configured settings cap (if any) remains the hard ceiling
+    lastContinuationTurnId: uuid3("last_continuation_turn_id"),
+    versionAtLastContinuation: integer2("version_at_last_continuation"),
+    // Postgres owns the continuation obligation. Terminal settlement advances
+    // wakeRevision in the same transaction that makes the session idle;
+    // materialization advances observedRevision only alongside the one typed
+    // update, timeline events, usage row, and workflow-wake outbox row.
+    // Temporal signals and workflow history are replaceable nudges over these
+    // monotonic revisions.
+    continuationWakeRevision: bigint3("continuation_wake_revision", { mode: "number" }).notNull().default(0),
+    continuationObservedRevision: bigint3("continuation_observed_revision", { mode: "number" }).notNull().default(0),
+    metadata: jsonb2("metadata").$type().notNull().default({}),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceIdentity: uniqueIndex3("session_goals_workspace_id_idx").on(
+      table.workspaceId,
+      table.id
+    ),
+    workspaceSession: uniqueIndex3("session_goals_workspace_session_idx").on(
+      table.workspaceId,
+      table.sessionId
+    ),
+    status: index3("session_goals_workspace_status_idx").on(table.workspaceId, table.status),
+    continuationRevisionValid: check3(
+      "session_goals_continuation_revision_check",
+      sql3`${table.continuationWakeRevision} >= 0 and ${table.continuationObservedRevision} >= 0 and ${table.continuationObservedRevision} <= ${table.continuationWakeRevision} and ${table.continuationWakeRevision} <= 9007199254740991 and ${table.continuationObservedRevision} <= 9007199254740991`
+    )
+  })
+);
+var codexCapacityWaiters = pgTable3(
+  "codex_capacity_waiters",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    sessionId: uuid3("session_id").notNull(),
+    goalId: uuid3("goal_id"),
+    blockedTurnId: uuid3("blocked_turn_id").notNull(),
+    blockedTurnGeneration: integer2("blocked_turn_generation").notNull(),
+    workflowId: text3("workflow_id").notNull(),
+    generation: integer2("generation").notNull().default(1),
+    status: text3("status").notNull().default("waiting"),
+    // waiting | resumed | superseded
+    goalVersion: integer2("goal_version"),
+    policyHash: text3("policy_hash"),
+    earliestResetAt: timestamp3("earliest_reset_at", { withTimezone: true }),
+    nextCheckAt: timestamp3("next_check_at", { withTimezone: true }).notNull(),
+    resetKind: text3("reset_kind").notNull(),
+    // authoritative | bounded_refresh
+    refreshAttempt: integer2("refresh_attempt").notNull().default(0),
+    // Coalescing outbox generation. Every eligibility-affecting mutation bumps
+    // wakeRevision. Duplicate/lost Temporal signals are harmless because only
+    // the row-locked evaluator moves observedWakeRevision and may enqueue work.
+    wakeRevision: integer2("wake_revision").notNull().default(1),
+    observedWakeRevision: integer2("observed_wake_revision").notNull().default(0),
+    lastWakeReason: text3("last_wake_reason").notNull().default("capacity_wait_armed"),
+    resumedUpdateId: uuid3("resumed_update_id"),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceSession: uniqueIndex3("codex_capacity_waiters_workspace_session_idx").on(
+      table.workspaceId,
+      table.sessionId
+    ),
+    workspaceId: uniqueIndex3("codex_capacity_waiters_workspace_id_idx").on(
+      table.workspaceId,
+      table.id
+    ),
+    pending: index3("codex_capacity_waiters_pending_idx").on(
+      table.workspaceId,
+      table.status,
+      table.nextCheckAt
+    ),
+    wakeRepair: index3("codex_capacity_waiters_wake_repair_idx").on(
+      table.status,
+      table.wakeRevision,
+      table.observedWakeRevision
+    )
+  })
+);
+var sessionEvents = pgTable3(
+  "session_events",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    sessionId: uuid3("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+    turnId: uuid3("turn_id"),
+    turnGeneration: integer2("turn_generation"),
+    turnAttemptId: uuid3("turn_attempt_id"),
+    turnAssociation: text3("turn_association"),
+    duplicateOfEventId: uuid3("duplicate_of_event_id"),
+    duplicateReason: text3("duplicate_reason"),
+    sequence: integer2("sequence").notNull(),
+    type: text3("type").notNull(),
+    payload: jsonb2("payload").$type().notNull().default({}),
+    clientEventId: text3("client_event_id"),
+    producerId: text3("producer_id"),
+    producerSeq: integer2("producer_seq"),
+    occurredAt: timestamp3("occurred_at", { withTimezone: true }).notNull().defaultNow(),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceAttempt: foreignKey({
+      name: "session_events_workspace_attempt_fk",
+      columns: [table.workspaceId, table.turnAttemptId],
+      foreignColumns: [sessionTurnAttempts.workspaceId, sessionTurnAttempts.id]
+    }).onDelete("restrict"),
+    sessionSequence: uniqueIndex3("session_events_workspace_session_sequence_idx").on(
+      table.workspaceId,
+      table.sessionId,
+      table.sequence
+    ),
+    clientEvent: uniqueIndex3("session_events_workspace_client_event_idx").on(table.workspaceId, table.sessionId, table.clientEventId).where(sql3`${table.clientEventId} is not null`),
+    producer: uniqueIndex3("session_events_workspace_producer_idx").on(table.workspaceId, table.sessionId, table.producerId, table.producerSeq).where(sql3`${table.producerId} is not null and ${table.producerSeq} is not null`),
+    sessionCreated: index3("session_events_workspace_session_created_idx").on(
+      table.workspaceId,
+      table.sessionId,
+      table.createdAt
+    ),
+    sessionTypeSequence: index3("session_events_workspace_session_type_sequence_idx").on(
+      table.workspaceId,
+      table.sessionId,
+      table.type,
+      table.sequence
+    ),
+    monitoringTail: index3("session_events_workspace_session_monitoring_tail_idx").on(table.workspaceId, table.sessionId, table.sequence).where(
+      sql3`${table.type} not in ('agent.message.delta', 'agent.reasoning.delta', 'sandbox.command.output.delta', 'terminal.pty.output.delta')`
+    ),
+    duplicateOfEvent: index3("session_events_duplicate_of_event_idx").on(table.duplicateOfEventId),
+    payloadBytes: check3(
+      "session_events_payload_bytes_check",
+      sql3`octet_length(${table.payload}::text) <= 65536`
+    ),
+    typeBytes: check3(
+      "session_events_type_bytes_check",
+      sql3`octet_length(${table.type}) <= 256 and position(E'\n' in ${table.type}) = 0 and position(E'\r' in ${table.type}) = 0`
+    ),
+    clientEventIdBytes: check3(
+      "session_events_client_event_id_bytes_check",
+      sql3`${table.clientEventId} is null or octet_length(${table.clientEventId}) <= 1024`
+    ),
+    producerIdBytes: check3(
+      "session_events_producer_id_bytes_check",
+      sql3`${table.producerId} is null or octet_length(${table.producerId}) <= 1024`
+    ),
+    turnAssociationBytes: check3(
+      "session_events_turn_association_bytes_check",
+      sql3`${table.turnAssociation} is null or octet_length(${table.turnAssociation}) <= 64`
+    ),
+    duplicateReasonBytes: check3(
+      "session_events_duplicate_reason_bytes_check",
+      sql3`${table.duplicateReason} is null or octet_length(${table.duplicateReason}) <= 4096`
+    )
+  })
+);
+var agentRunStates = pgTable3("agent_run_states", {
+  id: uuid3("id").primaryKey().defaultRandom(),
+  accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+  workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+  sessionId: uuid3("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  turnId: uuid3("turn_id").references(() => sessionTurns.id, {
+    onDelete: "set null"
+  }),
+  stateVersion: integer2("state_version").notNull(),
+  serializedRunState: text3("serialized_run_state").notNull(),
+  pendingApprovals: jsonb2("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 an approval resume 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: uuid3("frozen_codex_credential_id"),
+  // Exact provider rejection invalidates only the opaque reasoning identity
+  // inside this frozen state. The serialized receipt remains durable and
+  // auditable; the resume path neutralizes its provider-bound identity.
+  providerArtifactInvalidatedAt: timestamp3("provider_artifact_invalidated_at", {
+    withTimezone: true
+  }),
+  providerArtifactInvalidationReason: text3("provider_artifact_invalidation_reason"),
+  providerArtifactInvalidatedByAttemptId: uuid3("provider_artifact_invalidated_by_attempt_id"),
+  createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow()
+});
+var sessionHumanInputRequests = pgTable3(
+  "session_human_input_requests",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull(),
+    workspaceId: uuid3("workspace_id").notNull(),
+    sessionId: uuid3("session_id").notNull(),
+    turnId: uuid3("turn_id").notNull(),
+    turnGeneration: integer2("turn_generation").notNull(),
+    creationAttemptId: uuid3("creation_attempt_id").notNull(),
+    toolCallId: text3("tool_call_id").notNull(),
+    status: text3("status").notNull().default("pending"),
+    questions: jsonb2("questions").$type().notNull(),
+    allowSkip: boolean2("allow_skip").notNull().default(false),
+    response: jsonb2("response").$type(),
+    respondedBy: text3("responded_by"),
+    respondedAt: timestamp3("responded_at", { withTimezone: true }),
+    expiresAt: timestamp3("expires_at", { withTimezone: true }),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    creationAttemptOwner: foreignKey({
+      name: "session_human_input_requests_creation_attempt_fk",
+      columns: [
+        table.accountId,
+        table.workspaceId,
+        table.sessionId,
+        table.turnId,
+        table.creationAttemptId
+      ],
+      foreignColumns: [
+        sessionTurnAttempts.accountId,
+        sessionTurnAttempts.workspaceId,
+        sessionTurnAttempts.sessionId,
+        sessionTurnAttempts.turnId,
+        sessionTurnAttempts.id
+      ]
+    }).onDelete("cascade"),
+    toolCall: uniqueIndex3("session_human_input_requests_tool_call_uq").on(
+      table.workspaceId,
+      table.sessionId,
+      table.turnId,
+      table.toolCallId
+    ),
+    pendingSession: index3("session_human_input_requests_pending_session_idx").on(table.workspaceId, table.sessionId, table.createdAt, table.id).where(sql3`${table.status} = 'pending'`),
+    pendingExpiry: index3("session_human_input_requests_pending_expiry_idx").on(table.expiresAt, table.id).where(sql3`${table.status} = 'pending' and ${table.expiresAt} is not null`),
+    status: check3(
+      "session_human_input_requests_status_check",
+      sql3`${table.status} in ('pending','answered','skipped','expired','cancelled')`
+    ),
+    generation: check3(
+      "session_human_input_requests_generation_check",
+      sql3`${table.turnGeneration} > 0`
+    ),
+    toolCallBytes: check3(
+      "session_human_input_requests_tool_call_bytes_check",
+      sql3`octet_length(${table.toolCallId}) between 1 and 1024`
+    ),
+    questionsBytes: check3(
+      "session_human_input_requests_questions_bytes_check",
+      sql3`octet_length(${table.questions}::text) <= 49152`
+    ),
+    responseBytes: check3(
+      "session_human_input_requests_response_bytes_check",
+      sql3`${table.response} is null or octet_length(${table.response}::text) <= 49152`
+    ),
+    actorBytes: check3(
+      "session_human_input_requests_actor_bytes_check",
+      sql3`${table.respondedBy} is null or octet_length(${table.respondedBy}) <= 1024`
+    )
+  })
+);
+var sessionHistoryItems = pgTable3(
+  "session_history_items",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    sessionId: uuid3("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+    turnId: uuid3("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: jsonb2("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: boolean2("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: uuid3("producer_codex_credential_id"),
+    // An exact provider 400 can prove that an otherwise same-credential opaque
+    // reasoning artifact is no longer decryptable. Keep the original item and
+    // producer provenance immutable, but record the attempt-fenced rejection so
+    // later model reads omit only the provider-bound identity. No FK: the receipt
+    // must outlive operational attempt retention just like producer provenance.
+    providerArtifactInvalidatedAt: timestamp3("provider_artifact_invalidated_at", {
+      withTimezone: true
+    }),
+    providerArtifactInvalidationReason: text3("provider_artifact_invalidation_reason"),
+    providerArtifactInvalidatedByAttemptId: uuid3("provider_artifact_invalidated_by_attempt_id"),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    positionIdx: uniqueIndex3("session_history_items_position_idx").on(
+      table.workspaceId,
+      table.sessionId,
+      table.position
+    )
+  })
+);
+var sessionPendingToolCalls = pgTable3(
+  "session_pending_tool_calls",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    sessionId: uuid3("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+    turnId: uuid3("turn_id").notNull().references(() => sessionTurns.id, { onDelete: "cascade" }),
+    executionGeneration: integer2("execution_generation").notNull(),
+    attemptId: uuid3("attempt_id").notNull(),
+    callId: text3("call_id").notNull(),
+    callType: text3("call_type").notNull(),
+    callItem: jsonb2("call_item").$type().notNull(),
+    modelToolOutputTruncationTokens: integer2("model_tool_output_truncation_tokens"),
+    resultItem: jsonb2("result_item").$type(),
+    resultRecordedAt: timestamp3("result_recorded_at", { withTimezone: true }),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceAttempt: foreignKey({
+      name: "pending_tool_calls_workspace_attempt_fk",
+      columns: [table.workspaceId, table.attemptId],
+      foreignColumns: [sessionTurnAttempts.workspaceId, sessionTurnAttempts.id]
+    }).onDelete("restrict"),
+    turnCall: uniqueIndex3("session_pending_tool_calls_turn_call_idx").on(
+      table.workspaceId,
+      table.turnId,
+      table.callId
+    ),
+    sessionTurn: index3("session_pending_tool_calls_session_turn_idx").on(
+      table.workspaceId,
+      table.sessionId,
+      table.turnId
+    )
+  })
+);
+var sandboxSessionEnvelopes = pgTable3(
+  "sandbox_session_envelopes",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    sessionId: uuid3("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+    envelope: jsonb2("envelope").$type().notNull(),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    sessionIdx: uniqueIndex3("sandbox_session_envelopes_session_idx").on(
+      table.workspaceId,
+      table.sessionId
+    )
+  })
+);
+var sandboxCheckpointArtifactStateValues = [
+  "candidate",
+  "current",
+  "previous",
+  "delete_pending",
+  "deleting",
+  "delete_failed",
+  "deleted"
+];
+var sandboxCheckpointArtifacts = pgTable3(
+  "sandbox_checkpoint_artifacts",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull(),
+    workspaceId: uuid3("workspace_id").notNull(),
+    sandboxGroupId: uuid3("sandbox_group_id").notNull(),
+    sourceLeaseId: uuid3("source_lease_id").notNull(),
+    sourceLeaseEpoch: integer2("source_lease_epoch").notNull(),
+    sourceInstanceId: text3("source_instance_id"),
+    sourceWorkspaceGeneration: integer2("source_workspace_generation"),
+    provenance: text3("provenance", {
+      enum: ["native_capture", "legacy_provider_adopted"]
+    }).notNull(),
+    providerBackend: text3("provider_backend").notNull(),
+    providerBindingKey: text3("provider_binding_key").notNull(),
+    providerBinding: jsonb2("provider_binding").$type().notNull(),
+    objectKind: text3("object_kind", {
+      enum: ["modal_filesystem_snapshot", "modal_directory_snapshot"]
+    }).notNull(),
+    objectId: text3("object_id").notNull(),
+    archiveBase64: text3("archive_base64").notNull(),
+    archiveSha256: text3("archive_sha256").notNull(),
+    archiveBytes: integer2("archive_bytes").notNull(),
+    descriptor: jsonb2("descriptor").$type().notNull(),
+    descriptorRevision: text3("descriptor_revision").notNull(),
+    state: text3("state", { enum: sandboxCheckpointArtifactStateValues }).notNull().default("candidate"),
+    deleteAfter: timestamp3("delete_after", { withTimezone: true }),
+    deleteAttempts: integer2("delete_attempts").notNull().default(0),
+    deleteClaimId: uuid3("delete_claim_id"),
+    deleteClaimedAt: timestamp3("delete_claimed_at", { withTimezone: true }),
+    lastDeleteError: text3("last_delete_error"),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    publishedAt: timestamp3("published_at", { withTimezone: true }),
+    deletedAt: timestamp3("deleted_at", { withTimezone: true }),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    providerObject: uniqueIndex3("sandbox_checkpoint_artifacts_provider_object_uq").on(
+      table.providerBackend,
+      table.providerBindingKey,
+      table.objectId
+    ),
+    gc: index3("sandbox_checkpoint_artifacts_gc_idx").on(table.deleteAfter, table.createdAt, table.id).where(
+      sql3`${table.state} in (
+          'candidate', 'current', 'previous',
+          'delete_pending', 'delete_failed', 'deleting'
+        )`
+    ),
+    source: index3("sandbox_checkpoint_artifacts_source_idx").on(
+      table.workspaceId,
+      table.sandboxGroupId,
+      table.sourceLeaseId
+    ),
+    sourceValid: check3(
+      "sandbox_checkpoint_artifacts_source_check",
+      sql3`${table.sourceLeaseEpoch} >= 0
+        and (
+          (
+            ${table.provenance} = 'native_capture'
+            and ${table.sourceWorkspaceGeneration} is not null
+            and ${table.sourceWorkspaceGeneration} >= 0
+            and ${table.sourceInstanceId} is not null
+            and octet_length(${table.sourceInstanceId}) between 1 and 512
+          )
+          or (
+            ${table.provenance} = 'legacy_provider_adopted'
+            and ${table.sourceWorkspaceGeneration} is null
+            and ${table.sourceInstanceId} is null
+          )
+        )`
+    ),
+    providerValid: check3(
+      "sandbox_checkpoint_artifacts_provider_check",
+      sql3`${table.providerBackend} = 'modal'
+        and octet_length(${table.providerBindingKey}) between 1 and 1024
+        and jsonb_typeof(${table.providerBinding}) = 'object'
+        and ${table.providerBindingKey}::jsonb = ${table.providerBinding}
+        and ${table.objectKind} in ('modal_filesystem_snapshot', 'modal_directory_snapshot')
+        and octet_length(${table.objectId}) between 1 and 1024`
+    ),
+    archiveValid: check3(
+      "sandbox_checkpoint_artifacts_archive_check",
+      sql3`${table.archiveBytes} > 0
+        and octet_length(${table.archiveBase64}) > 0
+        and ${table.archiveSha256} ~ '^[0-9a-f]{64}$'
+        and jsonb_typeof(${table.descriptor}) = 'object'
+        and octet_length(${table.descriptorRevision}) between 1 and 256`
+    ),
+    stateValid: check3(
+      "sandbox_checkpoint_artifacts_state_check",
+      sql3`${table.state} in (
+        'candidate', 'current', 'previous', 'delete_pending',
+        'deleting', 'delete_failed', 'deleted'
+      )`
+    ),
+    deleteClaimValid: check3(
+      "sandbox_checkpoint_artifacts_delete_claim_check",
+      sql3`(${table.state} = 'deleting'
+          and ${table.deleteClaimId} is not null
+          and ${table.deleteClaimedAt} is not null)
+        or (${table.state} <> 'deleting'
+          and ${table.deleteClaimId} is null
+          and ${table.deleteClaimedAt} is null)`
+    )
+  })
+);
+var sandboxLeaseLivenessValues = ["cold", "warming", "warm", "draining"];
+var sandboxLeases = pgTable3(
+  "sandbox_leases",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    sandboxGroupId: uuid3("sandbox_group_id").notNull(),
+    liveness: text3("liveness", { enum: sandboxLeaseLivenessValues }).notNull().default("cold"),
+    refcount: integer2("refcount").notNull().default(0),
+    turnHolders: integer2("turn_holders").notNull().default(0),
+    viewerHolders: integer2("viewer_holders").notNull().default(0),
+    instanceId: text3("instance_id"),
+    backend: text3("backend").notNull(),
+    os: text3("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 requests a
+    // capture-and-drain rotation; N-holders are rejected (SandboxImageConflictError). Nullable — a
+    // legacy/cold row reads NULL = "image unknown", which never conflicts.
+    image: text3("image"),
+    // The frozen rig version the live box was created under (M3). Like `image`,
+    // this is SHARED STATE: all the box's sessions run the same rig-baked setup,
+    // so a resume resolving a DIFFERENT rig_version_id conflicts (a solo holder
+    // requests capture-and-drain rotation; N-holders throw SandboxRigConflictError).
+    // Nullable — a legacy/cold row or a rig-less session reads NULL = "rig
+    // unknown", which never conflicts. No FK (symmetric with sandbox_group_id's
+    // bare-uuid rationale: this lease outlives no single rig_versions row's RLS).
+    rigVersionId: uuid3("rig_version_id"),
+    dataPlaneUrl: text3("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: text3("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: integer2("lease_epoch").notNull().default(0),
+    // Monotonic mutation intent for the live workspace. Every acknowledged
+    // filesystem-writing operation advances this under the exact lease epoch +
+    // provider-instance fence BEFORE it reaches the provider. A verified
+    // archive fold copies the exact captured value into archive_generation in
+    // the same row update; equality is the only durable completeness proof.
+    workspaceGeneration: integer2("workspace_generation").notNull().default(0),
+    archiveGeneration: integer2("archive_generation"),
+    // Provider-native capture may pause the live box. The exact claim is
+    // acquired before provider I/O and cleared only after that capture settles;
+    // new holders and workspace mutations fence on it. The SQL constraint also
+    // requires the claimed generation to remain current, so an unaware writer
+    // cannot advance generation through an active capture.
+    archiveCaptureId: uuid3("archive_capture_id"),
+    archiveCaptureGeneration: integer2("archive_capture_generation"),
+    archiveCaptureStartedAt: timestamp3("archive_capture_started_at", {
+      withTimezone: true
+    }),
+    archiveCaptureDeadlineAt: timestamp3("archive_capture_deadline_at", {
+      withTimezone: true
+    }),
+    // 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: text3("resume_backend_id"),
+    resumeState: jsonb2("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: timestamp3("last_meter_at", { withTimezone: true }),
+    lastMeterTick: integer2("last_meter_tick").notNull().default(0),
+    providerCreatedAt: timestamp3("provider_created_at", { withTimezone: true }),
+    providerDeadlineAt: timestamp3("provider_deadline_at", { withTimezone: true }),
+    rotationRequestedAt: timestamp3("rotation_requested_at", { withTimezone: true }),
+    rotationReason: text3("rotation_reason", {
+      enum: ["provider_deadline", "operator"]
+    }),
+    // The SQL migration owns the two DEFERRABLE foreign keys and deferred
+    // scope/state constraint triggers. Drizzle does not model deferrability, so
+    // these remain bare UUIDs here rather than generating a stricter wrong FK.
+    currentCheckpointArtifactId: uuid3("current_checkpoint_artifact_id"),
+    previousCheckpointArtifactId: uuid3("previous_checkpoint_artifact_id"),
+    expiresAt: timestamp3("expires_at", { withTimezone: true }).notNull(),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    groupIdx: uniqueIndex3("sandbox_leases_group_idx").on(table.workspaceId, table.sandboxGroupId),
+    scopedId: uniqueIndex3("sandbox_leases_scoped_id_uq").on(
+      table.accountId,
+      table.workspaceId,
+      table.sandboxGroupId,
+      table.id
+    ),
+    accountWorkspaceId: uniqueIndex3("sandbox_leases_account_workspace_id_uq").on(
+      table.accountId,
+      table.workspaceId,
+      table.id
+    ),
+    reaperIdx: index3("sandbox_leases_reaper_idx").on(table.expiresAt).where(sql3`${table.liveness} in ('warming','warm','draining')`),
+    expiredDrainingInventory: index3("sandbox_leases_expired_draining_inventory_idx").on(table.expiresAt, table.backend).where(sql3`${table.liveness} = 'draining'`),
+    providerDeadline: index3("sandbox_leases_provider_deadline_idx").on(table.providerDeadlineAt, table.id).where(
+      sql3`${table.backend} = 'modal'
+          and ${table.liveness} in ('warming', 'warm')
+          and ${table.rotationRequestedAt} is null`
+    ),
+    workspaceGenerationValid: check3(
+      "sandbox_leases_workspace_generation_check",
+      sql3`${table.workspaceGeneration} >= 0`
+    ),
+    archiveGenerationValid: check3(
+      "sandbox_leases_archive_generation_check",
+      sql3`${table.archiveGeneration} is null
+        or (${table.archiveGeneration} >= 0
+          and ${table.archiveGeneration} <= ${table.workspaceGeneration})`
+    ),
+    archiveCaptureValid: check3(
+      "sandbox_leases_archive_capture_check",
+      sql3`(
+          ${table.archiveCaptureId} is null
+          and ${table.archiveCaptureGeneration} is null
+          and ${table.archiveCaptureStartedAt} is null
+          and ${table.archiveCaptureDeadlineAt} is null
+        ) or (
+          ${table.archiveCaptureId} is not null
+          and ${table.archiveCaptureGeneration} is not null
+          and ${table.archiveCaptureGeneration} = ${table.workspaceGeneration}
+          and ${table.archiveCaptureStartedAt} is not null
+          and ${table.archiveCaptureDeadlineAt} > ${table.archiveCaptureStartedAt}
+        )`
+    ),
+    archiveCaptureDeadline: index3("sandbox_leases_archive_capture_deadline_idx").on(table.archiveCaptureDeadlineAt, table.id).where(sql3`${table.archiveCaptureId} is not null`),
+    providerDeadlineValid: check3(
+      "sandbox_leases_provider_deadline_check",
+      sql3`(${table.providerCreatedAt} is null and ${table.providerDeadlineAt} is null)
+        or (${table.providerCreatedAt} is not null
+          and ${table.providerDeadlineAt} is not null
+          and ${table.providerDeadlineAt} > ${table.providerCreatedAt})`
+    ),
+    rotationValid: check3(
+      "sandbox_leases_rotation_check",
+      sql3`(${table.rotationRequestedAt} is null and ${table.rotationReason} is null)
+        or (${table.rotationRequestedAt} is not null
+          and ${table.rotationReason} in ('provider_deadline', 'operator'))`
+    ),
+    checkpointDistinct: check3(
+      "sandbox_leases_checkpoint_distinct_check",
+      sql3`${table.currentCheckpointArtifactId} is null
+        or ${table.previousCheckpointArtifactId} is null
+        or ${table.currentCheckpointArtifactId} <> ${table.previousCheckpointArtifactId}`
+    )
+  })
+);
+var sandboxLeaseHolders = pgTable3(
+  "sandbox_lease_holders",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    leaseId: uuid3("lease_id").notNull().references(() => sandboxLeases.id, { onDelete: "cascade" }),
+    kind: text3("kind", { enum: ["turn", "viewer", "direct", "process"] }).notNull(),
+    holderId: text3("holder_id").notNull(),
+    // The attributing session within the (possibly shared) group.
+    subjectId: uuid3("subject_id"),
+    lastHeartbeatAt: timestamp3("last_heartbeat_at", { withTimezone: true }).notNull().defaultNow(),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    leaseScope: foreignKey({
+      name: "sandbox_lease_holders_lease_scope_fk",
+      columns: [table.accountId, table.workspaceId, table.leaseId],
+      foreignColumns: [sandboxLeases.accountId, sandboxLeases.workspaceId, sandboxLeases.id]
+    }).onDelete("cascade"),
+    holderIdx: uniqueIndex3("sandbox_lease_holders_holder_idx").on(
+      table.leaseId,
+      table.kind,
+      table.holderId
+    ),
+    staleIdx: index3("sandbox_lease_holders_stale_idx").on(table.kind, table.lastHeartbeatAt),
+    leaseIdx: index3("sandbox_lease_holders_lease_idx").on(table.leaseId)
+  })
+);
+var sandboxWorkspaceMutationActorKindValues = ["turn", "direct", "process"];
+var sandboxWorkspaceMutationHolderKindValues = ["turn", "direct", "process"];
+var sandboxWorkspaceMutationAdmissions = pgTable3(
+  "sandbox_workspace_mutation_admissions",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull(),
+    workspaceId: uuid3("workspace_id").notNull(),
+    leaseId: uuid3("lease_id").notNull().references(() => sandboxLeases.id, { onDelete: "cascade" }),
+    sandboxGroupId: uuid3("sandbox_group_id").notNull(),
+    sessionId: uuid3("session_id").notNull(),
+    actorKind: text3("actor_kind", { enum: sandboxWorkspaceMutationActorKindValues }).notNull(),
+    actorId: uuid3("actor_id").notNull(),
+    // Exact turn authority is present only for actor_kind='turn'. Direct HTTP
+    // requests and retained processes never invent a turn or quiescence owner.
+    turnId: uuid3("turn_id"),
+    attemptId: uuid3("attempt_id"),
+    executionGeneration: integer2("execution_generation"),
+    holderKind: text3("holder_kind", {
+      enum: sandboxWorkspaceMutationHolderKindValues
+    }).notNull(),
+    holderId: text3("holder_id").notNull(),
+    leaseEpoch: integer2("lease_epoch").notNull(),
+    providerBackend: text3("provider_backend").notNull(),
+    providerInstanceId: text3("provider_instance_id").notNull(),
+    routeKind: text3("route_kind", { enum: ["home", "active"] }).notNull(),
+    // null route target means the persistable home/group provider. A non-null
+    // target is pinned together with the active pointer epoch observed when the
+    // operation was admitted.
+    routeTargetId: uuid3("route_target_id"),
+    routeEpoch: integer2("route_epoch").notNull(),
+    workspaceGeneration: integer2("workspace_generation").notNull(),
+    operation: text3("operation").notNull(),
+    providerOutcome: text3("provider_outcome", {
+      enum: ["resolved", "rejected", "retained"]
+    }),
+    admittedAt: timestamp3("admitted_at", { withTimezone: true }).notNull().defaultNow(),
+    settledAt: timestamp3("settled_at", { withTimezone: true })
+  },
+  (table) => ({
+    workspaceAccount: foreignKey({
+      name: "sandbox_workspace_mutation_admissions_workspace_account_fk",
+      columns: [table.workspaceId, table.accountId],
+      foreignColumns: [workspaces.id, workspaces.accountId]
+    }).onDelete("cascade"),
+    workspaceSession: foreignKey({
+      name: "sandbox_workspace_mutation_admissions_workspace_session_fk",
+      columns: [table.workspaceId, table.sessionId],
+      foreignColumns: [sessions.workspaceId, sessions.id]
+    }).onDelete("restrict"),
+    workspaceTurn: foreignKey({
+      name: "sandbox_workspace_mutation_admissions_workspace_turn_fk",
+      columns: [table.workspaceId, table.turnId],
+      foreignColumns: [sessionTurns.workspaceId, sessionTurns.id]
+    }).onDelete("restrict"),
+    workspaceAttempt: foreignKey({
+      name: "sandbox_workspace_mutation_admissions_workspace_attempt_fk",
+      columns: [table.workspaceId, table.attemptId],
+      foreignColumns: [sessionTurnAttempts.workspaceId, sessionTurnAttempts.id]
+    }).onDelete("restrict"),
+    leaseGeneration: uniqueIndex3("sandbox_workspace_mutation_admissions_lease_generation_uq").on(
+      table.leaseId,
+      table.workspaceGeneration
+    ),
+    scopedId: uniqueIndex3("sandbox_workspace_mutation_admissions_scoped_id_uq").on(
+      table.accountId,
+      table.workspaceId,
+      table.sessionId,
+      table.leaseId,
+      table.id
+    ),
+    blocking: index3("sandbox_workspace_mutation_admissions_blocking_idx").on(table.leaseId, table.workspaceGeneration).where(sql3`${table.settledAt} is null`),
+    attempt: index3("sandbox_workspace_mutation_admissions_attempt_idx").on(
+      table.workspaceId,
+      table.attemptId
+    ),
+    actor: index3("sandbox_workspace_mutation_admissions_actor_idx").on(
+      table.workspaceId,
+      table.actorKind,
+      table.actorId
+    ),
+    generationValid: check3(
+      "sandbox_workspace_mutation_admissions_generation_check",
+      sql3`${table.workspaceGeneration} > 0
+        and ${table.leaseEpoch} >= 0
+        and ${table.routeEpoch} >= 0
+        and (${table.executionGeneration} is null or ${table.executionGeneration} > 0)`
+    ),
+    actorValid: check3(
+      "sandbox_workspace_mutation_admissions_actor_check",
+      sql3`(
+          ${table.actorKind} = 'turn'
+          and ${table.actorId} = ${table.attemptId}
+          and ${table.turnId} is not null
+          and ${table.attemptId} is not null
+          and ${table.executionGeneration} is not null
+          and ${table.holderKind} = 'turn'
+        ) or (
+          ${table.actorKind} = 'direct'
+          and ${table.turnId} is null
+          and ${table.attemptId} is null
+          and ${table.executionGeneration} is null
+          and ${table.holderKind} = 'direct'
+        ) or (
+          ${table.actorKind} = 'process'
+          and ${table.turnId} is null
+          and ${table.attemptId} is null
+          and ${table.executionGeneration} is null
+          and ${table.holderKind} = 'process'
+        )`
+    ),
+    routeValid: check3(
+      "sandbox_workspace_mutation_admissions_route_check",
+      sql3`${table.actorKind} in ('turn', 'direct', 'process')
+        and ${table.holderKind} in ('turn', 'direct', 'process')
+        and octet_length(${table.holderId}) between 1 and 256
+        and octet_length(${table.providerBackend}) between 1 and 64
+        and octet_length(${table.providerInstanceId}) between 1 and 512
+        and ${table.routeKind} in ('home', 'active')
+        and (${table.routeKind} = 'active' or ${table.routeTargetId} is null)`
+    ),
+    operationValid: check3(
+      "sandbox_workspace_mutation_admissions_operation_check",
+      sql3`octet_length(${table.operation}) between 1 and 128`
+    ),
+    outcomeValid: check3(
+      "sandbox_workspace_mutation_admissions_outcome_check",
+      sql3`${table.providerOutcome} is null or ${table.providerOutcome} in ('resolved', 'rejected', 'retained')`
+    ),
+    settlementConsistent: check3(
+      "sandbox_workspace_mutation_admissions_settlement_check",
+      sql3`(${table.providerOutcome} is null and ${table.settledAt} is null)
+        or (${table.providerOutcome} = 'retained' and ${table.settledAt} is null)
+        or (${table.providerOutcome} in ('resolved', 'rejected') and ${table.settledAt} is not null)`
+    )
+  })
+);
+var sandboxRetainedProcessStateValues = ["active", "exited", "lost"];
+var sandboxRetainedProcesses = pgTable3(
+  "sandbox_retained_processes",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull(),
+    workspaceId: uuid3("workspace_id").notNull(),
+    sessionId: uuid3("session_id").notNull(),
+    leaseId: uuid3("lease_id").notNull(),
+    sandboxGroupId: uuid3("sandbox_group_id").notNull(),
+    parentAdmissionId: uuid3("parent_admission_id").notNull(),
+    holderId: text3("holder_id").notNull(),
+    ownerActorKind: text3("owner_actor_kind", { enum: ["turn", "direct"] }).notNull(),
+    ownerActorId: uuid3("owner_actor_id").notNull(),
+    ownerTurnId: uuid3("owner_turn_id"),
+    ownerAttemptId: uuid3("owner_attempt_id"),
+    ownerExecutionGeneration: integer2("owner_execution_generation"),
+    leaseEpoch: integer2("lease_epoch").notNull(),
+    providerBackend: text3("provider_backend").notNull(),
+    providerInstanceId: text3("provider_instance_id").notNull(),
+    // Provider object ids are namespace-scoped. New Modal processes bind the
+    // exact authenticated workspace before execution; legacy rows remain null
+    // until a positive lookup proves which namespace owns the historical box.
+    providerBindingKey: text3("provider_binding_key"),
+    providerBinding: jsonb2("provider_binding").$type(),
+    routeKind: text3("route_kind", { enum: ["home", "active"] }).notNull(),
+    routeTargetId: uuid3("route_target_id"),
+    routeEpoch: integer2("route_epoch").notNull(),
+    providerSessionId: integer2("provider_session_id").notNull(),
+    state: text3("state", { enum: sandboxRetainedProcessStateValues }).notNull().default("active"),
+    exitCode: integer2("exit_code"),
+    settlementReason: text3("settlement_reason"),
+    startedAt: timestamp3("started_at", { withTimezone: true }).notNull().defaultNow(),
+    settledAt: timestamp3("settled_at", { withTimezone: true }),
+    // Coordination state for bounded terminal-owner reconciliation. While a
+    // claim is live, reconcileAfter is its expiry; otherwise it is the next
+    // retry time. Becoming due only licenses an exact provider probe and is
+    // never exit/loss proof.
+    reconcileAfter: timestamp3("reconcile_after", { withTimezone: true }).notNull().defaultNow(),
+    reconcileClaimId: uuid3("reconcile_claim_id"),
+    reconcileClaimedAt: timestamp3("reconcile_claimed_at", { withTimezone: true }),
+    reconcileAttempts: integer2("reconcile_attempts").notNull().default(0),
+    lastReconcileOutcome: text3("last_reconcile_outcome"),
+    reconcileProofOutcome: text3("reconcile_proof_outcome", { enum: ["exited", "lost"] }),
+    reconcileProofExitCode: integer2("reconcile_proof_exit_code"),
+    reconcileProofReason: text3("reconcile_proof_reason"),
+    reconcileProofObservedAt: timestamp3("reconcile_proof_observed_at", { withTimezone: true })
+  },
+  (table) => ({
+    workspaceAccount: foreignKey({
+      name: "sandbox_retained_processes_workspace_account_fk",
+      columns: [table.workspaceId, table.accountId],
+      foreignColumns: [workspaces.id, workspaces.accountId]
+    }).onDelete("cascade"),
+    workspaceSession: foreignKey({
+      name: "sandbox_retained_processes_workspace_session_fk",
+      columns: [table.workspaceId, table.sessionId],
+      foreignColumns: [sessions.workspaceId, sessions.id]
+    }).onDelete("restrict"),
+    parentAdmissionScope: foreignKey({
+      name: "sandbox_retained_processes_parent_admission_scope_fk",
+      columns: [
+        table.accountId,
+        table.workspaceId,
+        table.sessionId,
+        table.leaseId,
+        table.parentAdmissionId
+      ],
+      foreignColumns: [
+        sandboxWorkspaceMutationAdmissions.accountId,
+        sandboxWorkspaceMutationAdmissions.workspaceId,
+        sandboxWorkspaceMutationAdmissions.sessionId,
+        sandboxWorkspaceMutationAdmissions.leaseId,
+        sandboxWorkspaceMutationAdmissions.id
+      ]
+    }).onDelete("restrict"),
+    scopedId: uniqueIndex3("sandbox_retained_processes_scoped_id_uq").on(
+      table.accountId,
+      table.workspaceId,
+      table.sessionId,
+      table.leaseId,
+      table.id
+    ),
+    parentAdmission: uniqueIndex3("sandbox_retained_processes_parent_admission_uq").on(
+      table.parentAdmissionId
+    ),
+    liveProviderSession: uniqueIndex3("sandbox_retained_processes_live_provider_session_uq").on(
+      table.leaseId,
+      table.leaseEpoch,
+      table.providerInstanceId,
+      table.routeEpoch,
+      table.providerSessionId
+    ).where(sql3`${table.state} = 'active'`),
+    holder: uniqueIndex3("sandbox_retained_processes_holder_uq").on(table.leaseId, table.holderId),
+    active: index3("sandbox_retained_processes_active_idx").on(table.workspaceId, table.sessionId, table.startedAt).where(sql3`${table.state} = 'active'`),
+    reconcileDue: index3("sandbox_retained_processes_reconcile_due_idx").on(table.reconcileAfter, table.startedAt, table.id).where(sql3`${table.state} = 'active'`),
+    activeInventory: index3("sandbox_retained_processes_active_inventory_idx").on(table.ownerActorKind, table.workspaceId, table.ownerTurnId, table.ownerAttemptId).where(sql3`${table.state} = 'active'`),
+    identityValid: check3(
+      "sandbox_retained_processes_identity_check",
+      sql3`${table.leaseEpoch} >= 0
+        and ${table.routeEpoch} >= 0
+        and ${table.providerSessionId} > 0
+        and octet_length(${table.holderId}) between 1 and 256
+        and octet_length(${table.providerBackend}) between 1 and 64
+        and octet_length(${table.providerInstanceId}) between 1 and 512
+        and (${table.routeKind} = 'active' or ${table.routeTargetId} is null)`
+    ),
+    ownerValid: check3(
+      "sandbox_retained_processes_owner_check",
+      sql3`(
+          ${table.ownerActorKind} = 'turn'
+          and ${table.ownerActorId} = ${table.ownerAttemptId}
+          and ${table.ownerTurnId} is not null
+          and ${table.ownerAttemptId} is not null
+          and ${table.ownerExecutionGeneration} > 0
+        ) or (
+          ${table.ownerActorKind} = 'direct'
+          and ${table.ownerTurnId} is null
+          and ${table.ownerAttemptId} is null
+          and ${table.ownerExecutionGeneration} is null
+        )`
+    ),
+    settlementValid: check3(
+      "sandbox_retained_processes_settlement_check",
+      sql3`(${table.state} = 'active' and ${table.settledAt} is null and ${table.exitCode} is null)
+        or (${table.state} = 'exited' and ${table.settledAt} is not null)
+        or (${table.state} = 'lost' and ${table.settledAt} is not null and ${table.exitCode} is null)`
+    ),
+    reasonValid: check3(
+      "sandbox_retained_processes_reason_check",
+      sql3`${table.settlementReason} is null
+        or octet_length(${table.settlementReason}) between 1 and 512`
+    ),
+    providerBindingValid: check3(
+      "sandbox_retained_processes_provider_binding_check",
+      sql3`(
+          ${table.providerBindingKey} is null
+          and ${table.providerBinding} is null
+        ) or (
+          ${table.providerBackend} = 'modal'
+          and octet_length(${table.providerBindingKey}) between 1 and 1024
+          and jsonb_typeof(${table.providerBinding}) = 'object'
+          and ${table.providerBindingKey}::jsonb = ${table.providerBinding}
+          and ${table.providerBindingKey} = format(
+            '{"version":1,"serverUrl":%s,"workspaceName":%s,"environment":%s}',
+            to_jsonb(${table.providerBinding} ->> 'serverUrl')::text,
+            to_jsonb(${table.providerBinding} ->> 'workspaceName')::text,
+            to_jsonb(${table.providerBinding} ->> 'environment')::text
+          )
+          and ${table.providerBinding} = jsonb_build_object(
+            'version', 1,
+            'serverUrl', ${table.providerBinding} ->> 'serverUrl',
+            'workspaceName', ${table.providerBinding} ->> 'workspaceName',
+            'environment', ${table.providerBinding} ->> 'environment'
+          )
+          and coalesce(octet_length(${table.providerBinding} ->> 'serverUrl'), 0) > 0
+          and coalesce(octet_length(${table.providerBinding} ->> 'workspaceName'), 0) > 0
+          and ${table.providerBinding} ->> 'environment' is not null
+        )`
+    ),
+    reconcileClaimValid: check3(
+      "sandbox_retained_processes_reconcile_claim_check",
+      sql3`(${table.reconcileClaimId} is null and ${table.reconcileClaimedAt} is null)
+        or (${table.reconcileClaimId} is not null and ${table.reconcileClaimedAt} is not null)`
+    ),
+    reconcileAttemptsValid: check3(
+      "sandbox_retained_processes_reconcile_attempts_check",
+      sql3`${table.reconcileAttempts} >= 0`
+    ),
+    reconcileOutcomeValid: check3(
+      "sandbox_retained_processes_reconcile_outcome_check",
+      sql3`${table.lastReconcileOutcome} is null
+        or octet_length(${table.lastReconcileOutcome}) between 1 and 64`
+    ),
+    reconcileProofValid: check3(
+      "sandbox_retained_processes_reconcile_proof_check",
+      sql3`(
+          ${table.reconcileProofOutcome} is null
+          and ${table.reconcileProofExitCode} is null
+          and ${table.reconcileProofReason} is null
+          and ${table.reconcileProofObservedAt} is null
+        ) or (
+          ${table.reconcileProofOutcome} = 'exited'
+          and ${table.reconcileProofExitCode} is not null
+          and ${table.reconcileProofReason} = 'provider_exit_banner'
+          and ${table.reconcileProofObservedAt} is not null
+        ) or (
+          ${table.reconcileProofOutcome} = 'lost'
+          and ${table.reconcileProofExitCode} is null
+          and ${table.reconcileProofReason} in (
+            'provider_session_lost_banner', 'provider_instance_not_found',
+            'provider_instance_terminated'
+          )
+          and ${table.reconcileProofObservedAt} is not null
+        )`
+    )
+  })
+);
+var sessionRecordingStateValues = [
+  "recording",
+  "finalizing",
+  "available",
+  "failed"
+];
+var sessionRecordingModeValues = ["manual", "on-turn", "on-verify"];
+var sessionRecordingCodecValues = ["h264-mp4", "vp9-webm"];
+var sessionRecordings = pgTable3(
+  "session_recordings",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    sessionId: uuid3("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+    turnId: uuid3("turn_id").references(() => sessionTurns.id, {
+      onDelete: "set null"
+    }),
+    state: text3("state", { enum: sessionRecordingStateValues }).notNull(),
+    mode: text3("mode", { enum: sessionRecordingModeValues }).notNull(),
+    codec: text3("codec", { enum: sessionRecordingCodecValues }).notNull(),
+    storageKey: text3("storage_key"),
+    sizeBytes: bigint3("size_bytes", { mode: "number" }),
+    durationSeconds: numeric("duration_seconds").$type(),
+    width: integer2("width").notNull(),
+    height: integer2("height").notNull(),
+    reason: text3("reason"),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    finalizedAt: timestamp3("finalized_at", { withTimezone: true })
+  },
+  (table) => ({
+    sessionIdx: index3("session_recordings_session_idx").on(
+      table.workspaceId,
+      table.sessionId,
+      table.createdAt
+    )
+  })
+);
+var workspaceCaptures = pgTable3(
+  "workspace_captures",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    sessionId: uuid3("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+    turnId: uuid3("turn_id").references(() => sessionTurns.id, {
+      onDelete: "set null"
+    }),
+    revision: bigint3("revision", { mode: "number" }).notNull(),
+    leaseEpoch: integer2("lease_epoch").notNull(),
+    // 'available' on a committed capture. 'failed' reserved for a future two-phase
+    // write; the current synchronous capture only ever inserts 'available'.
+    state: text3("state", { enum: ["available", "failed"] }).notNull().default("available"),
+    // Single JSON manifest blob (tree index + repos + file refs) — the cold-paint payload.
+    manifestKey: text3("manifest_key"),
+    // The fs tree index blob, kept separate from the manifest so the API can inline
+    // or sign it independently of the (usually small) manifest metadata.
+    treeIndexKey: text3("tree_index_key"),
+    // Content-addressed after-image blob keys this revision references (GC input).
+    blobKeys: jsonb2("blob_keys").$type().notNull().default([]),
+    sizeBytes: bigint3("size_bytes", { mode: "number" }),
+    stats: jsonb2("stats").$type().notNull().default({}),
+    capturedAt: timestamp3("captured_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    sessionRevision: uniqueIndex3("workspace_captures_session_revision_idx").on(
+      table.sessionId,
+      table.revision
+    ),
+    latest: index3("workspace_captures_latest_idx").on(
+      table.workspaceId,
+      table.sessionId,
+      table.revision
+    )
+  })
+);
+var sandboxPtySessions = pgTable3(
+  "sandbox_pty_sessions",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    // == ptyId on the wire
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    sessionId: uuid3("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+    leaseId: uuid3("lease_id"),
+    sandboxGroupId: uuid3("sandbox_group_id"),
+    retainedProcessId: uuid3("retained_process_id"),
+    openAdmissionId: uuid3("open_admission_id"),
+    // Copied provider locator for the adopted retained process.
+    execSessionId: integer2("exec_session_id"),
+    leaseEpoch: integer2("lease_epoch").notNull(),
+    providerBackend: text3("provider_backend"),
+    providerInstanceId: text3("provider_instance_id"),
+    routeKind: text3("route_kind", { enum: ["home", "active"] }),
+    routeTargetId: uuid3("route_target_id"),
+    routeEpoch: integer2("route_epoch"),
+    cols: integer2("cols").notNull(),
+    rows: integer2("rows").notNull(),
+    shell: text3("shell").notNull(),
+    cwd: text3("cwd").notNull(),
+    status: text3("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: text3("opened_by").notNull(),
+    lastInputAt: timestamp3("last_input_at", { withTimezone: true }).notNull().defaultNow(),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    closedAt: timestamp3("closed_at", { withTimezone: true })
+  },
+  (table) => ({
+    retainedProcessScope: foreignKey({
+      name: "sandbox_pty_sessions_retained_process_scope_fk",
+      columns: [
+        table.accountId,
+        table.workspaceId,
+        table.sessionId,
+        table.leaseId,
+        table.retainedProcessId
+      ],
+      foreignColumns: [
+        sandboxRetainedProcesses.accountId,
+        sandboxRetainedProcesses.workspaceId,
+        sandboxRetainedProcesses.sessionId,
+        sandboxRetainedProcesses.leaseId,
+        sandboxRetainedProcesses.id
+      ]
+    }).onDelete("restrict"),
+    openIdx: index3("sandbox_pty_sessions_session_idx").on(table.workspaceId, table.sessionId).where(sql3`${table.status} = 'open'`),
+    processIdx: uniqueIndex3("sandbox_pty_sessions_open_process_uq").on(table.retainedProcessId).where(sql3`${table.status} = 'open'`),
+    openIdentityValid: check3(
+      "sandbox_pty_sessions_open_identity_check",
+      sql3`${table.status} <> 'open' or (
+        ${table.leaseId} is not null
+        and ${table.sandboxGroupId} is not null
+        and ${table.retainedProcessId} is not null
+        and ${table.openAdmissionId} is not null
+        and ${table.execSessionId} > 0
+        and octet_length(${table.providerBackend}) between 1 and 64
+        and octet_length(${table.providerInstanceId}) between 1 and 512
+        and ${table.routeKind} in ('home', 'active')
+        and (${table.routeKind} = 'active' or ${table.routeTargetId} is null)
+        and ${table.routeEpoch} is not null
+        and ${table.leaseEpoch} >= 0
+        and ${table.routeEpoch} >= 0
+      )`
+    )
+  })
+);
+var enrollmentExposureValues = ["whole-machine"];
+var enrollmentStatusValues = ["active", "revoked"];
+var enrollmentOsValues = ["linux", "macos", "windows"];
+var sandboxKindValues = ["modal", "selfhosted"];
+var enrollments = pgTable3(
+  "enrollments",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    // The agent's ed25519 public key (the machine identity).
+    pubkey: text3("pubkey").notNull(),
+    exposure: text3("exposure", { enum: enrollmentExposureValues }).notNull().default("whole-machine"),
+    hasDisplay: boolean2("has_display").notNull().default(false),
+    // Refreshed from every connect Hello (Capabilities.op_stream); false for
+    // agents predating the op-stream engine.
+    opStream: boolean2("op_stream").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: text3("desktop_unavailable_reason"),
+    allowScreenControl: boolean2("allow_screen_control").notNull().default(false),
+    status: text3("status", { enum: enrollmentStatusValues }).notNull().default("active"),
+    os: text3("os", { enum: enrollmentOsValues }).notNull().default("linux"),
+    arch: text3("arch").notNull().default("x86_64"),
+    // Heartbeat liveness cursor. Null until the first connect.
+    lastSeenAt: timestamp3("last_seen_at", { withTimezone: true }),
+    // Clean going-offline marker (migration 0049). Set when the machine announces a
+    // typed GoingOffline (user-stop / self-update / host-shutdown); the liveness
+    // derivation reads an un-cleared marker as OFFLINE immediately, regardless of a
+    // still-fresh last_seen. Any newer liveness signal (a reconnect Hello or a
+    // fresher heartbeat via touchEnrollmentLastSeen) clears BOTH back to NULL. NULL
+    // (the default) ⇒ no goodbye pending — today's last_seen-aging behavior.
+    wentOfflineAt: timestamp3("went_offline_at", { withTimezone: true }),
+    wentOfflineReason: text3("went_offline_reason"),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    revokedAt: timestamp3("revoked_at", { withTimezone: true }),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    // One enrollment per (workspace, pubkey): a re-enroll is an idempotent upsert.
+    workspacePubkey: uniqueIndex3("enrollments_workspace_pubkey_idx").on(
+      table.workspaceId,
+      table.pubkey
+    ),
+    // List a workspace's ACTIVE machines without scanning revoked rows.
+    workspaceStatus: index3("enrollments_workspace_status_idx").on(table.workspaceId, table.status)
+  })
+);
+var deviceEnrollmentStatusValues = ["pending", "approved", "denied", "consumed"];
+var deviceEnrollmentRequests = pgTable3(
+  "device_enrollment_requests",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    // The opaque code the agent polls with (unguessable, single-use). Unique.
+    deviceCode: text3("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: text3("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: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    // The agent's ed25519 public key (the machine identity the enrollment binds to).
+    pubkey: text3("pubkey").notNull(),
+    os: text3("os", { enum: enrollmentOsValues }).notNull().default("linux"),
+    arch: text3("arch").notNull().default("x86_64"),
+    machineName: text3("machine_name"),
+    // The exposure the agent REQUESTED (whole-machine in v1; loudly consented at
+    // approve). Mirrors the enrollment column domain.
+    requestedExposure: text3("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: boolean2("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: boolean2("requests_screen_control").notNull().default(false),
+    status: text3("status", { enum: deviceEnrollmentStatusValues }).notNull().default("pending"),
+    // ── LOUD CONSENT capture (who/when/what), stamped at approve ──────────────
+    approvedBySubjectId: text3("approved_by_subject_id"),
+    approvedBySubjectLabel: text3("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: boolean2("allow_screen_control").notNull().default(false),
+    approvedAt: timestamp3("approved_at", { withTimezone: true }),
+    // The enrollment + sandbox the approve produced (acceptance #2: an enrollment
+    // row AND a sandbox row appear). Null until approved.
+    enrollmentId: uuid3("enrollment_id").references(() => enrollments.id, {
+      onDelete: "set null"
+    }),
+    sandboxId: uuid3("sandbox_id").references(() => sandboxes.id, {
+      onDelete: "set null"
+    }),
+    // The short-TTL expiry; a pending row past this is EXPIRED on poll.
+    expiresAt: timestamp3("expires_at", { withTimezone: true }).notNull(),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    // The device_code is the agent's poll key — globally unique + indexed.
+    deviceCode: uniqueIndex3("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: uniqueIndex3("device_enrollment_requests_user_code_pending_idx").on(table.userCode).where(sql3`${table.status} = 'pending'`),
+    workspaceCreated: index3("device_enrollment_requests_workspace_created_idx").on(
+      table.workspaceId,
+      table.createdAt
+    ),
+    expires: index3("device_enrollment_requests_expires_idx").on(table.expiresAt)
+  })
+);
+var sandboxes = pgTable3(
+  "sandboxes",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    kind: text3("kind", { enum: sandboxKindValues }).notNull(),
+    name: text3("name").notNull(),
+    enrollmentId: uuid3("enrollment_id").references(() => enrollments.id, {
+      onDelete: "set null"
+    }),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceCreated: index3("sandboxes_workspace_created_idx").on(
+      table.workspaceId,
+      table.createdAt
+    ),
+    enrollment: index3("sandboxes_enrollment_idx").on(table.enrollmentId).where(sql3`${table.enrollmentId} is not null`)
+  })
+);
+var machineMetricsLatest = pgTable3(
+  "machine_metrics_latest",
+  {
+    enrollmentId: uuid3("enrollment_id").primaryKey().references(() => enrollments.id, { onDelete: "cascade" }),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("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: bigint3("mem_used_bytes", { mode: "number" }),
+    memTotalBytes: bigint3("mem_total_bytes", { mode: "number" }),
+    diskUsedBytes: bigint3("disk_used_bytes", { mode: "number" }),
+    diskTotalBytes: bigint3("disk_total_bytes", { mode: "number" }),
+    gpuUtilPercent: numeric("gpu_util_percent").$type(),
+    gpuMemUsedBytes: bigint3("gpu_mem_used_bytes", { mode: "number" }),
+    gpuMemTotalBytes: bigint3("gpu_mem_total_bytes", { mode: "number" }),
+    contention: numeric("contention").$type(),
+    sampledAt: timestamp3("sampled_at", { withTimezone: true }).notNull(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspace: index3("machine_metrics_latest_workspace_idx").on(table.workspaceId)
+  })
+);
+var machineMetricsSeries = pgTable3(
+  "machine_metrics_series",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    enrollmentId: uuid3("enrollment_id").notNull().references(() => enrollments.id, { onDelete: "cascade" }),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("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: bigint3("mem_used_bytes", { mode: "number" }),
+    memTotalBytes: bigint3("mem_total_bytes", { mode: "number" }),
+    diskUsedBytes: bigint3("disk_used_bytes", { mode: "number" }),
+    diskTotalBytes: bigint3("disk_total_bytes", { mode: "number" }),
+    gpuUtilPercent: numeric("gpu_util_percent").$type(),
+    gpuMemUsedBytes: bigint3("gpu_mem_used_bytes", { mode: "number" }),
+    gpuMemTotalBytes: bigint3("gpu_mem_total_bytes", { mode: "number" }),
+    contention: numeric("contention").$type(),
+    sampledAt: timestamp3("sampled_at", { withTimezone: true }).notNull(),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    enrollmentSampled: index3("machine_metrics_series_enrollment_sampled_idx").on(
+      table.enrollmentId,
+      table.sampledAt
+    ),
+    sampled: index3("machine_metrics_series_sampled_idx").on(table.sampledAt)
+  })
+);
+var scheduledTasks = pgTable3(
+  "scheduled_tasks",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    name: text3("name").notNull(),
+    status: text3("status").notNull().default("active"),
+    schedule: jsonb2("schedule").$type().notNull(),
+    temporalScheduleId: text3("temporal_schedule_id").notNull(),
+    runMode: text3("run_mode").notNull().default("new_session_per_run"),
+    overlapPolicy: text3("overlap_policy").notNull().default("allow_concurrent"),
+    agentConfig: jsonb2("agent_config").$type().notNull(),
+    reusableSessionId: uuid3("reusable_session_id").references(() => sessions.id, {
+      onDelete: "set null"
+    }),
+    variableSetId: uuid3("variable_set_id").references(() => workspaceVariableSets.id, {
+      onDelete: "restrict"
+    }),
+    // The rig this task's runs ride; the active version is resolved per fire
+    // (migration 0047). NULL ⇒ no rig. FK (-> rigs(id) ON DELETE SET NULL) lives
+    // in migration 0047 (forward-reference pattern). Consumed in M3.
+    rigId: uuid3("rig_id"),
+    metadata: jsonb2("metadata").$type().notNull().default({}),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    temporalScheduleId: uniqueIndex3("scheduled_tasks_workspace_temporal_schedule_id_idx").on(
+      table.workspaceId,
+      table.temporalScheduleId
+    ),
+    status: index3("scheduled_tasks_workspace_status_idx").on(table.workspaceId, table.status),
+    variableSet: index3("scheduled_tasks_variable_set_idx").on(
+      table.workspaceId,
+      table.variableSetId
+    )
+  })
+);
+var scheduledTaskRuns = pgTable3(
+  "scheduled_task_runs",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    taskId: uuid3("task_id").notNull().references(() => scheduledTasks.id, { onDelete: "cascade" }),
+    status: text3("status").notNull().default("queued"),
+    triggerType: text3("trigger_type").notNull(),
+    scheduledAt: timestamp3("scheduled_at", { withTimezone: true }),
+    firedAt: timestamp3("fired_at", { withTimezone: true }).notNull().defaultNow(),
+    sessionId: uuid3("session_id").references(() => sessions.id, {
+      onDelete: "set null"
+    }),
+    triggerEventId: uuid3("trigger_event_id"),
+    // Stable Temporal producer identity. Activity replay/re-dispatch returns
+    // the exact run instead of allocating a second schedule source row.
+    producerKey: text3("producer_key"),
+    error: text3("error"),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    taskCreated: index3("scheduled_task_runs_workspace_task_created_idx").on(
+      table.workspaceId,
+      table.taskId,
+      table.createdAt
+    ),
+    session: index3("scheduled_task_runs_workspace_session_idx").on(
+      table.workspaceId,
+      table.sessionId
+    ),
+    producer: uniqueIndex3("scheduled_task_runs_producer_key_uq").on(table.workspaceId, table.producerKey).where(sql3`${table.producerKey} is not null`)
+  })
+);
+var githubInstallations = pgTable3(
+  "github_installations",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    installationId: integer2("installation_id").notNull(),
+    githubAccountId: bigint3("github_account_id", { mode: "number" }),
+    accountLogin: text3("account_login"),
+    accountType: text3("account_type"),
+    repositoryScope: text3("repository_scope").notNull().default("all"),
+    linkedBySubjectId: text3("linked_by_subject_id"),
+    githubActorId: bigint3("github_actor_id", { mode: "number" }),
+    githubActorLogin: text3("github_actor_login"),
+    authorityKind: text3("authority_kind"),
+    authorityCheckedAt: timestamp3("authority_checked_at", { withTimezone: true }),
+    authorityExpiresAt: timestamp3("authority_expires_at", { withTimezone: true }),
+    authorityNonce: text3("authority_nonce"),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceInstallation: uniqueIndex3("github_installations_workspace_installation_idx").on(
+      table.workspaceId,
+      table.installationId
+    ),
+    installation: index3("github_installations_installation_idx").on(table.installationId),
+    workspace: index3("github_installations_workspace_idx").on(table.workspaceId),
+    repositoryScopeCheck: check3(
+      "github_installations_repository_scope_check",
+      sql3`${table.repositoryScope} in ('all', 'selected')`
+    ),
+    authorityKindCheck: check3(
+      "github_installations_authority_kind_check",
+      sql3`
+        (
+          ${table.githubAccountId} is null
+          and ${table.githubActorId} is null
+          and ${table.githubActorLogin} is null
+          and ${table.authorityKind} is null
+          and ${table.authorityCheckedAt} is null
+          and ${table.authorityExpiresAt} is null
+          and ${table.authorityNonce} is null
+        )
+        or (
+          ${table.githubAccountId} is not null
+          and ${table.githubAccountId} > 0
+          and ${table.githubActorId} is not null
+          and ${table.githubActorId} > 0
+          and ${table.githubActorLogin} is not null
+          and length(${table.githubActorLogin}) > 0
+          and ${table.accountLogin} is not null
+          and length(${table.accountLogin}) > 0
+          and ${table.accountType} is not null
+          and ${table.linkedBySubjectId} is not null
+          and length(${table.linkedBySubjectId}) > 0
+          and ${table.authorityKind} is not null
+          and ${table.authorityCheckedAt} is not null
+          and ${table.authorityExpiresAt} is not null
+          and ${table.authorityCheckedAt} < ${table.authorityExpiresAt}
+          and ${table.authorityExpiresAt} <= ${table.authorityCheckedAt} + interval '10 minutes'
+          and ${table.authorityNonce} is not null
+          and length(${table.authorityNonce}) > 0
+          and ${table.repositoryScope} = 'selected'
+          and (
+            (
+              ${table.authorityKind} = 'personal_owner'
+              and ${table.accountType} = 'User'
+              and ${table.githubActorId} = ${table.githubAccountId}
+            )
+            or (
+              ${table.authorityKind} = 'organization_owner'
+              and ${table.accountType} = 'Organization'
+            )
+          )
+        )
+      `
+    ),
+    authorityNonce: uniqueIndex3("github_installations_authority_nonce_uq").on(table.authorityNonce).where(sql3`${table.authorityNonce} is not null`)
+  })
+);
+var githubInstallationRepositories = pgTable3(
+  "github_installation_repositories",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    installationId: integer2("installation_id").notNull(),
+    repositoryId: bigint3("repository_id", { mode: "number" }).notNull(),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    installationRepository: uniqueIndex3("github_install_repo_workspace_installation_repo_idx").on(
+      table.workspaceId,
+      table.installationId,
+      table.repositoryId
+    ),
+    workspaceInstallation: index3("github_install_repo_workspace_installation_idx").on(
+      table.workspaceId,
+      table.installationId
+    ),
+    workspaceAccount: foreignKey({
+      columns: [table.workspaceId, table.accountId],
+      foreignColumns: [workspaces.id, workspaces.accountId],
+      name: "github_installation_repositories_workspace_account_fk"
+    }).onDelete("cascade"),
+    installationBinding: foreignKey({
+      columns: [table.workspaceId, table.installationId],
+      foreignColumns: [githubInstallations.workspaceId, githubInstallations.installationId],
+      name: "github_installation_repositories_installation_fk"
+    }).onDelete("cascade")
+  })
+);
+var usageEvents = pgTable3(
+  "usage_events",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    subjectId: text3("subject_id"),
+    eventType: text3("event_type").notNull(),
+    quantity: bigint3("quantity", { mode: "number" }).notNull(),
+    unit: text3("unit").notNull(),
+    sourceResourceType: text3("source_resource_type"),
+    sourceResourceId: text3("source_resource_id"),
+    // Exact execution source for host usage export. These are deliberately
+    // validated soft references rather than cascading foreign keys: usage is
+    // an immutable billing/audit fact and must retain its source identity after
+    // a session or turn is deleted.
+    sessionId: uuid3("session_id"),
+    turnId: uuid3("turn_id"),
+    turnAttemptId: uuid3("turn_attempt_id"),
+    initiatorKind: text3("initiator_kind"),
+    initiatorSubjectId: text3("initiator_subject_id"),
+    initiatorContext: jsonb2("initiator_context").$type().notNull().default({}),
+    origin: text3("origin"),
+    idempotencyKey: text3("idempotency_key").notNull(),
+    occurredAt: timestamp3("occurred_at", { withTimezone: true }).notNull(),
+    recordedAt: timestamp3("recorded_at", { withTimezone: true }).notNull().defaultNow(),
+    exportedToBillingAt: timestamp3("exported_to_billing_at", {
+      withTimezone: true
+    }),
+    billingProviderEventId: text3("billing_provider_event_id")
+  },
+  (table) => ({
+    idempotency: uniqueIndex3("usage_events_idempotency_idx").on(table.idempotencyKey),
+    workspaceMetric: index3("usage_events_workspace_metric_idx").on(
+      table.workspaceId,
+      table.eventType,
+      table.occurredAt
+    ),
+    accountMetric: index3("usage_events_account_metric_idx").on(
+      table.accountId,
+      table.eventType,
+      table.occurredAt
+    ),
+    workspaceSession: index3("usage_events_workspace_session_idx").on(
+      table.workspaceId,
+      table.sessionId,
+      table.occurredAt
+    ),
+    contextHierarchy: check3(
+      "usage_events_context_hierarchy_check",
+      sql3`(${table.turnId} is null or ${table.sessionId} is not null)
+        and (${table.turnAttemptId} is null or ${table.turnId} is not null)`
+    ),
+    initiatorConsistent: check3(
+      "usage_events_initiator_check",
+      sql3`(${table.initiatorKind} is null and ${table.initiatorSubjectId} is null)
+        or (${table.initiatorKind} in ('subject', 'service')
+          and ${table.initiatorSubjectId} is not null
+          and octet_length(${table.initiatorSubjectId}) between 1 and 1024)`
+    ),
+    attributionContextBytes: check3(
+      "usage_events_initiator_context_bytes_check",
+      sql3`octet_length(${table.initiatorContext}::text) <= 4096`
+    ),
+    originValid: check3(
+      "usage_events_origin_check",
+      sql3`${table.origin} is null or ${table.origin} in (
+        'user', 'scheduled_task', 'api', 'goal', 'system', 'compaction'
+      )`
+    )
+  })
+);
+var modelCallFacts = pgTable3(
+  "model_call_facts",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    sessionId: uuid3("session_id").notNull(),
+    turnId: uuid3("turn_id").notNull(),
+    turnAttemptId: uuid3("turn_attempt_id"),
+    sourceKey: text3("source_key").notNull(),
+    provider: text3("provider").notNull(),
+    providerApi: text3("provider_api").notNull(),
+    model: text3("model").notNull(),
+    billingPath: text3("billing_path").notNull(),
+    turnSource: text3("turn_source"),
+    initiatorKind: text3("initiator_kind"),
+    initiatorSubjectId: text3("initiator_subject_id"),
+    scheduledTaskId: uuid3("scheduled_task_id"),
+    inputTokens: bigint3("input_tokens", { mode: "number" }),
+    outputTokens: bigint3("output_tokens", { mode: "number" }),
+    cachedTokens: bigint3("cached_tokens", { mode: "number" }),
+    cacheWriteTokens: bigint3("cache_write_tokens", { mode: "number" }),
+    reasoningTokens: bigint3("reasoning_tokens", { mode: "number" }),
+    totalTokens: bigint3("total_tokens", { mode: "number" }),
+    pricedCostMicros: bigint3("priced_cost_micros", { mode: "number" }).notNull().default(0),
+    occurredAt: timestamp3("occurred_at", { withTimezone: true }).notNull(),
+    recordedAt: timestamp3("recorded_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceTurnSource: uniqueIndex3("model_call_facts_workspace_turn_source_uq").on(
+      table.workspaceId,
+      table.turnId,
+      table.sourceKey
+    ),
+    workspaceOccurred: index3("model_call_facts_workspace_occurred_idx").on(
+      table.workspaceId,
+      table.occurredAt
+    ),
+    workspaceProviderModelOccurred: index3(
+      "model_call_facts_workspace_provider_model_occurred_idx"
+    ).on(table.workspaceId, table.provider, table.model, table.occurredAt),
+    workspaceSessionOccurred: index3("model_call_facts_workspace_session_occurred_idx").on(
+      table.workspaceId,
+      table.sessionId,
+      table.occurredAt
+    ),
+    workspaceScheduledTaskOccurred: index3("model_call_facts_workspace_scheduled_task_occurred_idx").on(table.workspaceId, table.scheduledTaskId, table.occurredAt).where(sql3`${table.scheduledTaskId} is not null`),
+    workspaceAccount: foreignKey({
+      name: "model_call_facts_workspace_account_fk",
+      columns: [table.workspaceId, table.accountId],
+      foreignColumns: [workspaces.id, workspaces.accountId]
+    }).onDelete("cascade"),
+    billingPathValid: check3(
+      "model_call_facts_billing_path_check",
+      sql3`${table.billingPath} in ('opengeni_credits', 'external')`
+    ),
+    pricedCostNonNegative: check3(
+      "model_call_facts_priced_cost_check",
+      sql3`${table.pricedCostMicros} >= 0`
+    ),
+    initiatorConsistent: check3(
+      "model_call_facts_initiator_check",
+      sql3`(${table.initiatorKind} is null and ${table.initiatorSubjectId} is null)
+        or (${table.initiatorKind} in ('subject', 'service')
+          and ${table.initiatorSubjectId} is not null
+          and octet_length(${table.initiatorSubjectId}) between 1 and 1024)`
+    ),
+    sourceKeyBytes: check3(
+      "model_call_facts_source_key_bytes_check",
+      sql3`octet_length(${table.sourceKey}) between 1 and 1024`
+    ),
+    providerBytes: check3(
+      "model_call_facts_provider_bytes_check",
+      sql3`octet_length(${table.provider}) between 1 and 256`
+    ),
+    providerApiBytes: check3(
+      "model_call_facts_provider_api_bytes_check",
+      sql3`octet_length(${table.providerApi}) between 1 and 256`
+    ),
+    modelBytes: check3(
+      "model_call_facts_model_bytes_check",
+      sql3`octet_length(${table.model}) between 1 and 512`
+    )
+  })
+);
+var hostExportConfig = pgTable3(
+  "host_export_config",
+  {
+    id: integer2("id").primaryKey().default(1),
+    sessionEventsEnabled: boolean2("session_events_enabled").notNull().default(false),
+    usageEventsEnabled: boolean2("usage_events_enabled").notNull().default(false),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    singleton: check3("host_export_config_singleton_check", sql3`${table.id} = 1`)
+  })
+);
+var hostExportOutbox = pgTable3(
+  "host_export_outbox",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    exportKind: text3("export_kind").notNull(),
+    exportCursor: bigint3("export_cursor", { mode: "bigint" }),
+    sourceId: uuid3("source_id").notNull(),
+    accountId: uuid3("account_id").notNull(),
+    workspaceId: uuid3("workspace_id").notNull(),
+    sessionId: uuid3("session_id"),
+    rootSessionId: uuid3("root_session_id"),
+    turnId: uuid3("turn_id"),
+    turnGeneration: integer2("turn_generation"),
+    turnAttemptId: uuid3("turn_attempt_id"),
+    sessionSequence: integer2("session_sequence"),
+    clientEventId: text3("client_event_id"),
+    turnAssociation: text3("turn_association"),
+    duplicateOfEventId: uuid3("duplicate_of_event_id"),
+    duplicateReason: text3("duplicate_reason"),
+    eventType: text3("event_type").notNull(),
+    idempotencyKey: text3("idempotency_key").notNull(),
+    initiator: jsonb2("initiator").$type(),
+    initiatorContext: jsonb2("initiator_context").$type().notNull().default({}),
+    origin: text3("origin"),
+    payload: jsonb2("payload").$type().notNull(),
+    envelopeBytes: integer2("envelope_bytes").notNull(),
+    occurredAt: timestamp3("occurred_at", { withTimezone: true }).notNull(),
+    sourceRecordedAt: timestamp3("source_recorded_at", { withTimezone: true }).notNull(),
+    enqueuedAt: timestamp3("enqueued_at", { withTimezone: true }).notNull()
+  },
+  (table) => ({
+    kindValid: check3(
+      "host_export_outbox_kind_check",
+      sql3`${table.exportKind} in ('session_event', 'usage_event')`
+    ),
+    rootSessionCaptured: check3(
+      "host_export_outbox_root_session_check",
+      sql3`${table.sessionId} is null or ${table.rootSessionId} is not null`
+    ),
+    sourceUnique: uniqueIndex3("host_export_outbox_source_uq").on(table.exportKind, table.sourceId),
+    cursorUnique: uniqueIndex3("host_export_outbox_cursor_uq").on(table.exportKind, table.exportCursor).where(sql3`${table.exportCursor} is not null`),
+    unassigned: index3("host_export_outbox_unassigned_idx").on(table.exportKind, table.enqueuedAt, table.id).where(sql3`${table.exportCursor} is null`),
+    unassignedSession: index3("host_export_outbox_unassigned_session_idx").on(table.exportKind, table.sessionId, table.sessionSequence).where(sql3`${table.exportCursor} is null and ${table.sessionId} is not null`),
+    contextBytes: check3(
+      "host_export_outbox_context_bytes_check",
+      sql3`octet_length(${table.initiatorContext}::text) <= 4096`
+    ),
+    originValid: check3(
+      "host_export_outbox_origin_check",
+      sql3`${table.origin} is null or ${table.origin} in (
+        'user', 'scheduled_task', 'api', 'goal', 'system', 'compaction'
+      )`
+    )
+  })
+);
+var hostExportCursorState = pgTable3(
+  "host_export_cursor_state",
+  {
+    exportKind: text3("export_kind").primaryKey(),
+    nextCursor: bigint3("next_cursor", { mode: "bigint" }).notNull().default(1n),
+    prunedThrough: bigint3("pruned_through", { mode: "bigint" }).notNull().default(0n),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    kindValid: check3(
+      "host_export_cursor_state_kind_check",
+      sql3`${table.exportKind} in ('session_event', 'usage_event')`
+    ),
+    cursorValid: check3(
+      "host_export_cursor_state_next_check",
+      sql3`${table.nextCursor} > 0 and ${table.prunedThrough} >= 0
+        and ${table.prunedThrough} < ${table.nextCursor}`
+    )
+  })
+);
+var hostExportConsumers = pgTable3(
+  "host_export_consumers",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    consumerId: text3("consumer_id").notNull(),
+    exportKind: text3("export_kind").notNull(),
+    checkpoint: bigint3("checkpoint", { mode: "bigint" }).notNull().default(0n),
+    enabled: boolean2("enabled").notNull().default(true),
+    leaseToken: uuid3("lease_token"),
+    leaseHolderId: text3("lease_holder_id"),
+    leaseExpiresAt: timestamp3("lease_expires_at", { withTimezone: true }),
+    leaseFrom: bigint3("lease_from", { mode: "bigint" }),
+    leaseThrough: bigint3("lease_through", { mode: "bigint" }),
+    consecutiveFailures: integer2("consecutive_failures").notNull().default(0),
+    nextAttemptAt: timestamp3("next_attempt_at", { withTimezone: true }).notNull().defaultNow(),
+    lastError: text3("last_error"),
+    lastErrorAt: timestamp3("last_error_at", { withTimezone: true }),
+    blockedAt: timestamp3("blocked_at", { withTimezone: true }),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    consumerKind: uniqueIndex3("host_export_consumers_kind_id_uq").on(
+      table.exportKind,
+      table.consumerId
+    ),
+    kindValid: check3(
+      "host_export_consumers_kind_check",
+      sql3`${table.exportKind} in ('session_event', 'usage_event')`
+    ),
+    checkpointValid: check3("host_export_consumers_checkpoint_check", sql3`${table.checkpoint} >= 0`),
+    due: index3("host_export_consumers_due_idx").on(
+      table.enabled,
+      table.blockedAt,
+      table.nextAttemptAt
+    )
+  })
+);
+var hostExportDeadLetters = pgTable3(
+  "host_export_dead_letters",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    consumerId: text3("consumer_id").notNull(),
+    exportKind: text3("export_kind").notNull(),
+    exportCursor: bigint3("export_cursor", { mode: "bigint" }).notNull(),
+    sourceId: uuid3("source_id").notNull(),
+    reason: text3("reason").notNull(),
+    envelope: jsonb2("envelope").$type().notNull(),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    consumerCursor: uniqueIndex3("host_export_dead_letters_consumer_cursor_uq").on(
+      table.exportKind,
+      table.consumerId,
+      table.exportCursor
+    ),
+    kindValid: check3(
+      "host_export_dead_letters_kind_check",
+      sql3`${table.exportKind} in ('session_event', 'usage_event')`
+    ),
+    reasonValid: check3(
+      "host_export_dead_letters_reason_check",
+      sql3`length(${table.reason}) between 1 and 500`
+    ),
+    envelopeBytes: check3(
+      "host_export_dead_letters_envelope_bytes_check",
+      sql3`pg_column_size(${table.envelope}) <= 114688`
+    )
+  })
+);
+var creditLedgerEntries = pgTable3(
+  "credit_ledger_entries",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").references(() => workspaces.id, {
+      onDelete: "set null"
+    }),
+    type: text3("type").notNull(),
+    amountMicros: bigint3("amount_micros", { mode: "number" }).notNull(),
+    currency: text3("currency").notNull().default("usd"),
+    sourceType: text3("source_type"),
+    sourceId: text3("source_id"),
+    idempotencyKey: text3("idempotency_key").notNull(),
+    metadata: jsonb2("metadata").$type().notNull().default({}),
+    occurredAt: timestamp3("occurred_at", { withTimezone: true }).notNull().defaultNow(),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    idempotency: uniqueIndex3("credit_ledger_entries_idempotency_idx").on(table.idempotencyKey),
+    accountCreated: index3("credit_ledger_entries_account_created_idx").on(
+      table.accountId,
+      table.createdAt
+    )
+  })
+);
+var billingCustomers = pgTable3(
+  "billing_customers",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    provider: text3("provider").notNull().default("stripe"),
+    providerCustomerId: text3("provider_customer_id").notNull(),
+    email: text3("email"),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    accountProvider: uniqueIndex3("billing_customers_account_provider_idx").on(
+      table.accountId,
+      table.provider
+    ),
+    providerCustomer: uniqueIndex3("billing_customers_provider_customer_idx").on(
+      table.provider,
+      table.providerCustomerId
+    )
+  })
+);
+var stripeWebhookEvents = pgTable3("stripe_webhook_events", {
+  id: text3("id").primaryKey(),
+  type: text3("type").notNull(),
+  livemode: text3("livemode").notNull().default("false"),
+  payload: jsonb2("payload").$type().notNull(),
+  processedAt: timestamp3("processed_at", { withTimezone: true }),
+  createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow()
+});
+var auditEvents = pgTable3(
+  "audit_events",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").references(() => managedAccounts.id, {
+      onDelete: "set null"
+    }),
+    workspaceId: uuid3("workspace_id").references(() => workspaces.id, {
+      onDelete: "set null"
+    }),
+    subjectId: text3("subject_id"),
+    action: text3("action").notNull(),
+    targetType: text3("target_type"),
+    targetId: text3("target_id"),
+    metadata: jsonb2("metadata").$type().notNull().default({}),
+    occurredAt: timestamp3("occurred_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    accountCreated: index3("audit_events_account_created_idx").on(table.accountId, table.occurredAt),
+    workspaceCreated: index3("audit_events_workspace_created_idx").on(
+      table.workspaceId,
+      table.occurredAt
+    )
+  })
+);
+var packInstallations = pgTable3(
+  "pack_installations",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    packId: text3("pack_id").notNull(),
+    status: text3("status").notNull().default("active"),
+    metadata: jsonb2("metadata").$type().notNull().default({}),
+    enabledAt: timestamp3("enabled_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspacePack: uniqueIndex3("pack_installations_workspace_pack_idx").on(
+      table.workspaceId,
+      table.packId
+    ),
+    status: index3("pack_installations_workspace_status_idx").on(table.workspaceId, table.status)
+  })
+);
+var workspacePacks = pgTable3(
+  "workspace_packs",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    packId: text3("pack_id").notNull(),
+    manifest: jsonb2("manifest").$type().notNull(),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspacePack: uniqueIndex3("workspace_packs_workspace_pack_idx").on(
+      table.workspaceId,
+      table.packId
+    )
+  })
+);
+var importBatches = pgTable3(
+  "import_batches",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    source: text3("source").notNull(),
+    snapshotDate: timestamp3("snapshot_date", { withTimezone: true }).notNull(),
+    snapshotRef: text3("snapshot_ref"),
+    attributionNote: text3("attribution_note").notNull(),
+    importedCount: integer2("imported_count").notNull().default(0),
+    skippedCount: integer2("skipped_count").notNull().default(0),
+    quarantinedCount: integer2("quarantined_count").notNull().default(0),
+    logoFailureCount: integer2("logo_failure_count").notNull().default(0),
+    staleCount: integer2("stale_count").notNull().default(0),
+    details: jsonb2("details").$type().notNull().default({}),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    sourceSnapshot: index3("import_batches_source_snapshot_idx").on(
+      table.source,
+      table.snapshotDate
+    ),
+    createdAt: index3("import_batches_created_at_idx").on(table.createdAt)
+  })
+);
+var capabilityCatalogItems = pgTable3(
+  "capability_catalog_items",
+  {
+    id: text3("id").notNull(),
+    accountId: uuid3("account_id").references(() => managedAccounts.id, {
+      onDelete: "cascade"
+    }),
+    workspaceId: uuid3("workspace_id").references(() => workspaces.id, {
+      onDelete: "cascade"
+    }),
+    kind: text3("kind").notNull(),
+    source: text3("source").notNull().default("manual"),
+    name: text3("name").notNull(),
+    description: text3("description"),
+    category: text3("category").notNull().default("custom"),
+    tags: jsonb2("tags").$type().notNull().default([]),
+    homepageUrl: text3("homepage_url"),
+    endpointUrl: text3("endpoint_url"),
+    installUrl: text3("install_url"),
+    authModel: text3("auth_model"),
+    providerDomain: text3("provider_domain"),
+    surfaceType: text3("surface_type"),
+    transport: text3("transport"),
+    mcpUrl: text3("mcp_url"),
+    authKind: text3("auth_kind"),
+    credentialFacts: jsonb2("credential_facts").$type().notNull().default([]),
+    tier: text3("tier"),
+    provenance: text3("provenance"),
+    logoAssetPath: text3("logo_asset_path"),
+    importBatchId: uuid3("import_batch_id").references(() => importBatches.id, {
+      onDelete: "set null"
+    }),
+    stale: boolean2("stale").notNull().default(false),
+    staleAt: timestamp3("stale_at", { withTimezone: true }),
+    metadata: jsonb2("metadata").$type().notNull().default({}),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceCapability: uniqueIndex3("capability_catalog_items_workspace_capability_idx").on(
+      table.workspaceId,
+      table.id
+    ),
+    registrySurface: uniqueIndex3("capability_catalog_items_registry_surface_idx").on(
+      table.source,
+      table.providerDomain,
+      table.mcpUrl
+    ),
+    globalCapability: uniqueIndex3("capability_catalog_items_global_capability_idx").on(table.id).where(sql3`${table.workspaceId} is null`),
+    kind: index3("capability_catalog_items_workspace_kind_idx").on(table.workspaceId, table.kind),
+    category: index3("capability_catalog_items_workspace_category_idx").on(
+      table.workspaceId,
+      table.category
+    ),
+    source: index3("capability_catalog_items_workspace_source_idx").on(
+      table.workspaceId,
+      table.source
+    ),
+    providerDomain: index3("capability_catalog_items_provider_domain_idx").on(table.providerDomain),
+    importBatch: index3("capability_catalog_items_import_batch_idx").on(table.importBatchId),
+    stale: index3("capability_catalog_items_source_stale_idx").on(table.source, table.stale)
+  })
+);
+var capabilityInstallations = pgTable3(
+  "capability_installations",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    capabilityId: text3("capability_id").notNull(),
+    kind: text3("kind").notNull(),
+    status: text3("status").notNull().default("active"),
+    config: jsonb2("config").$type().notNull().default({}),
+    metadata: jsonb2("metadata").$type().notNull().default({}),
+    enabledAt: timestamp3("enabled_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceCapability: uniqueIndex3("capability_installations_workspace_capability_idx").on(
+      table.workspaceId,
+      table.capabilityId
+    ),
+    kind: index3("capability_installations_workspace_kind_idx").on(table.workspaceId, table.kind),
+    status: index3("capability_installations_workspace_status_idx").on(
+      table.workspaceId,
+      table.status
+    )
+  })
+);
+var socialConnections = pgTable3(
+  "social_connections",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    provider: text3("provider").notNull(),
+    accountHandle: text3("account_handle").notNull(),
+    accountName: text3("account_name"),
+    externalAccountId: text3("external_account_id"),
+    status: text3("status").notNull().default("connected"),
+    scopes: jsonb2("scopes").$type().notNull().default([]),
+    credentialRef: text3("credential_ref"),
+    tokenMetadata: jsonb2("token_metadata").$type().notNull().default({}),
+    metadata: jsonb2("metadata").$type().notNull().default({}),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceProviderHandle: uniqueIndex3("social_connections_workspace_provider_handle_idx").on(
+      table.workspaceId,
+      table.provider,
+      table.accountHandle
+    ),
+    providerStatus: index3("social_connections_workspace_provider_status_idx").on(
+      table.workspaceId,
+      table.provider,
+      table.status
+    )
+  })
+);
+var socialPosts = pgTable3(
+  "social_posts",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    connectionId: uuid3("connection_id").notNull().references(() => socialConnections.id, { onDelete: "cascade" }),
+    provider: text3("provider").notNull(),
+    externalPostId: text3("external_post_id"),
+    url: text3("url"),
+    authorHandle: text3("author_handle"),
+    text: text3("text").notNull(),
+    publishedAt: timestamp3("published_at", { withTimezone: true }).notNull(),
+    metrics: jsonb2("metrics").$type().notNull().default({}),
+    raw: jsonb2("raw").$type().notNull().default({}),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    connectionExternalPost: uniqueIndex3("social_posts_workspace_connection_external_post_idx").on(
+      table.workspaceId,
+      table.connectionId,
+      table.externalPostId
+    ),
+    connectionPublished: index3("social_posts_workspace_connection_published_idx").on(
+      table.workspaceId,
+      table.connectionId,
+      table.publishedAt
+    ),
+    providerPublished: index3("social_posts_workspace_provider_published_idx").on(
+      table.workspaceId,
+      table.provider,
+      table.publishedAt
+    )
+  })
+);
+var rigs = pgTable3(
+  "rigs",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    name: text3("name").notNull(),
+    description: text3("description"),
+    // Attribution string: 'user:<subject>' | 'session:<id>' | 'system'.
+    createdBy: text3("created_by"),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceName: uniqueIndex3("rigs_workspace_name_idx").on(table.workspaceId, table.name),
+    workspaceCreated: index3("rigs_workspace_created_idx").on(table.workspaceId, table.createdAt)
+  })
+);
+var rigVersions = pgTable3(
+  "rig_versions",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    rigId: uuid3("rig_id").notNull().references(() => rigs.id, { onDelete: "cascade" }),
+    version: integer2("version").notNull(),
+    image: text3("image"),
+    setupScript: text3("setup_script"),
+    // Self-declared health checks: [{ name, command }].
+    checks: jsonb2("checks").$type().notNull().default([]),
+    // Registered credential-hook names (resolved to hook implementations in M3).
+    credentialHooks: jsonb2("credential_hooks").$type().notNull().default([]),
+    // Variable-set ids layered below the session's variable set at run time (M3).
+    defaultVariableSetIds: jsonb2("default_variable_set_ids").$type().notNull().default([]),
+    changelog: text3("changelog"),
+    createdBy: text3("created_by"),
+    active: boolean2("active").notNull().default(false),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    rigVersion: uniqueIndex3("rig_versions_rig_version_idx").on(table.rigId, table.version),
+    // At most one active version per rig — the single-active invariant, in the DB.
+    rigActive: uniqueIndex3("rig_versions_rig_active_idx").on(table.rigId).where(sql3`${table.active}`),
+    workspaceRig: index3("rig_versions_workspace_rig_idx").on(
+      table.workspaceId,
+      table.rigId,
+      table.version
+    )
+  })
+);
+var rigChanges = pgTable3(
+  "rig_changes",
+  {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    accountId: uuid3("account_id").notNull().references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid3("workspace_id").notNull().references(() => workspaces.id, { onDelete: "cascade" }),
+    rigId: uuid3("rig_id").notNull().references(() => rigs.id, { onDelete: "cascade" }),
+    baseVersionId: uuid3("base_version_id").references(() => rigVersions.id, {
+      onDelete: "set null"
+    }),
+    // 'setup_append' | 'definition_edit' (CHECK in migration 0047).
+    kind: text3("kind").notNull(),
+    payload: jsonb2("payload").$type().notNull(),
+    // 'proposed' | 'verifying' | 'merged' | 'rejected' | 'failed' (CHECK in 0047).
+    status: text3("status").notNull().default("proposed"),
+    proposedBy: text3("proposed_by"),
+    verification: jsonb2("verification").$type(),
+    resultVersionId: uuid3("result_version_id").references(() => rigVersions.id, {
+      onDelete: "set null"
+    }),
+    createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    workspaceRig: index3("rig_changes_workspace_rig_idx").on(
+      table.workspaceId,
+      table.rigId,
+      table.createdAt
+    ),
+    workspaceStatus: index3("rig_changes_workspace_status_idx").on(table.workspaceId, table.status)
+  })
+);
+
+export {
+  workspaceInstructionPolicyRevisions,
+  workspaceInstructionPolicyHeads,
+  workspaceInstructionPolicyActivationEvents,
+  preferenceRegistryPreferences,
+  preferenceRegistryRevisions,
+  preferenceRegistryEvents,
+  preferenceRegistrySnapshots,
+  managedAccounts,
+  workspaces,
+  nestedAgentDepthConfiguration,
+  workspaceInferenceControls,
+  workspaceSessionActivityRevisions,
+  workspaceMemberships,
+  apiKeys,
+  workspaceVariableSets,
+  workspaceVariableSetVariables,
+  codexSubscriptionCredentials,
+  codexResetRedemptionAttempts,
+  connections,
+  slackBotPostOperations,
+  slackBotDeleteOperations,
+  integrationOauthClients,
+  integrationOauthStateNonces,
+  codexRotationSettings,
+  workspaceModelPolicies,
+  codexCredentialLeases,
+  sessions,
+  sessionSpawnDenials,
+  sessionPins,
+  sessionListSnapshots,
+  sessionMcpServers,
+  files,
+  fileUploads,
+  documentBases,
+  documents,
+  documentChunks,
+  knowledgeMemories,
+  sessionTurns,
+  sessionTurnAttempts,
+  sessionCommandReceipts,
+  workspaceControlEvents,
+  sessionAttemptInterruptions,
+  composerDrafts,
+  newSessionDrafts,
+  sessionSystemUpdates,
+  sessionSystemUpdateOutbox,
+  sessionWorkflowWakeOutbox,
+  sessionGoals,
+  codexCapacityWaiters,
+  sessionEvents,
+  agentRunStates,
+  sessionHumanInputRequests,
+  sessionHistoryItems,
+  sessionPendingToolCalls,
+  sandboxSessionEnvelopes,
+  sandboxCheckpointArtifactStateValues,
+  sandboxCheckpointArtifacts,
+  sandboxLeaseLivenessValues,
+  sandboxLeases,
+  sandboxLeaseHolders,
+  sandboxWorkspaceMutationActorKindValues,
+  sandboxWorkspaceMutationHolderKindValues,
+  sandboxWorkspaceMutationAdmissions,
+  sandboxRetainedProcessStateValues,
+  sandboxRetainedProcesses,
+  sessionRecordingStateValues,
+  sessionRecordingModeValues,
+  sessionRecordingCodecValues,
+  sessionRecordings,
+  workspaceCaptures,
+  sandboxPtySessions,
+  enrollmentExposureValues,
+  enrollmentStatusValues,
+  enrollmentOsValues,
+  sandboxKindValues,
+  enrollments,
+  deviceEnrollmentStatusValues,
+  deviceEnrollmentRequests,
+  sandboxes,
+  machineMetricsLatest,
+  machineMetricsSeries,
+  scheduledTasks,
+  scheduledTaskRuns,
+  githubInstallations,
+  githubInstallationRepositories,
+  usageEvents,
+  modelCallFacts,
+  hostExportConfig,
+  hostExportOutbox,
+  hostExportCursorState,
+  hostExportConsumers,
+  hostExportDeadLetters,
+  creditLedgerEntries,
+  billingCustomers,
+  stripeWebhookEvents,
+  auditEvents,
+  packInstallations,
+  workspacePacks,
+  importBatches,
+  capabilityCatalogItems,
+  capabilityInstallations,
+  socialConnections,
+  socialPosts,
+  rigs,
+  rigVersions,
+  rigChanges,
+  schema_exports
+};
+//# sourceMappingURL=chunk-HZD7KVAR.js.map