@refrainai/cli 0.4.1

package/dist/chunk-CLYJHKPY.js

@@ -0,0 +1,1131 @@
+#!/usr/bin/env node
+import {
+  __export
+} from "./chunk-2H7UOFLK.js";
+
+// src/server/db/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  account: () => account,
+  apiKeys: () => apiKeys,
+  dataMigrationHistory: () => dataMigrationHistory,
+  invitations: () => invitations,
+  jobAiMetrics: () => jobAiMetrics,
+  jobApprovalRequests: () => jobApprovalRequests,
+  jobArtifacts: () => jobArtifacts,
+  jobDebugSuggestions: () => jobDebugSuggestions,
+  jobDebugWarnings: () => jobDebugWarnings,
+  jobExecutionConfigs: () => jobExecutionConfigs,
+  jobGenerateConfigs: () => jobGenerateConfigs,
+  jobRecordedSteps: () => jobRecordedSteps,
+  jobResultDiagnostics: () => jobResultDiagnostics,
+  jobResults: () => jobResults,
+  jobReviewResults: () => jobReviewResults,
+  jobReviewedSteps: () => jobReviewedSteps,
+  jobVariables: () => jobVariables,
+  jobs: () => jobs,
+  runbookSecrets: () => runbookSecrets,
+  runbookSettings: () => runbookSettings,
+  runbookSteps: () => runbookSteps,
+  runbookVariables: () => runbookVariables,
+  runbookVersionReviews: () => runbookVersionReviews,
+  runbookVersions: () => runbookVersions,
+  runbooks: () => runbooks,
+  schedules: () => schedules,
+  session: () => session,
+  telemetryFailureEvents: () => telemetryFailureEvents,
+  telemetryFailurePatterns: () => telemetryFailurePatterns,
+  telemetryJobSummaries: () => telemetryJobSummaries,
+  telemetryResolutionOutcomes: () => telemetryResolutionOutcomes,
+  telemetrySuggestionOutcomes: () => telemetrySuggestionOutcomes,
+  tenantDevelopmentSettings: () => tenantDevelopmentSettings,
+  tenantExecutionConfigs: () => tenantExecutionConfigs,
+  tenantExecutionSettings: () => tenantExecutionSettings,
+  tenantMembers: () => tenantMembers,
+  tenantModelOverrides: () => tenantModelOverrides,
+  tenantModelProviders: () => tenantModelProviders,
+  tenantUsage: () => tenantUsage,
+  tenants: () => tenants,
+  user: () => user,
+  verification: () => verification
+});
+import { pgTable, text, timestamp, index, unique, uuid, boolean, foreignKey, uniqueIndex, integer, real, jsonb } from "drizzle-orm/pg-core";
+var dataMigrationHistory = pgTable("data_migration_history", {
+  name: text().primaryKey().notNull(),
+  executedAt: timestamp("executed_at").defaultNow().notNull()
+});
+var verification = pgTable("verification", {
+  id: text().primaryKey().notNull(),
+  identifier: text().notNull(),
+  value: text().notNull(),
+  expiresAt: timestamp("expires_at").notNull(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()).notNull()
+}, (table) => [
+  index("verification_identifier_idx").using("btree", table.identifier.asc().nullsLast().op("text_ops"))
+]);
+var tenants = pgTable("tenants", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  name: text().notNull(),
+  slug: text().notNull(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()).notNull(),
+  tier: text("tier", { enum: ["community", "pro", "team", "business", "enterprise"] }).default("community").notNull(),
+  locale: text("locale", { enum: ["en", "ja"] }).default("en").notNull(),
+  onboardingCompletedAt: timestamp("onboarding_completed_at")
+}, (table) => [
+  unique("tenants_slug_unique").on(table.slug)
+]);
+var user = pgTable("user", {
+  id: text().primaryKey().notNull(),
+  name: text().notNull(),
+  email: text().notNull(),
+  emailVerified: boolean("email_verified").default(false).notNull(),
+  image: text(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()).notNull(),
+  onboardingCompletedAt: timestamp("onboarding_completed_at")
+}, (table) => [
+  unique("user_email_unique").on(table.email)
+]);
+var account = pgTable("account", {
+  id: text().primaryKey().notNull(),
+  accountId: text("account_id").notNull(),
+  providerId: text("provider_id").notNull(),
+  userId: text("user_id").notNull(),
+  accessToken: text("access_token"),
+  refreshToken: text("refresh_token"),
+  idToken: text("id_token"),
+  accessTokenExpiresAt: timestamp("access_token_expires_at"),
+  refreshTokenExpiresAt: timestamp("refresh_token_expires_at"),
+  scope: text(),
+  password: text(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()).notNull()
+}, (table) => [
+  index("account_userId_idx").using("btree", table.userId.asc().nullsLast().op("text_ops")),
+  foreignKey({
+    columns: [table.userId],
+    foreignColumns: [user.id],
+    name: "account_user_id_user_id_fk"
+  }).onDelete("cascade")
+]);
+var apiKeys = pgTable("api_keys", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  tenantId: uuid("tenant_id").notNull(),
+  createdBy: text("created_by").notNull(),
+  name: text().notNull(),
+  keyHash: text("key_hash").notNull(),
+  keyPrefix: text("key_prefix").notNull(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  revokedAt: timestamp("revoked_at"),
+  lastUsedAt: timestamp("last_used_at")
+}, (table) => [
+  uniqueIndex("api_keys_keyHash_idx").using("btree", table.keyHash.asc().nullsLast().op("text_ops")),
+  index("api_keys_tenantId_idx").using("btree", table.tenantId.asc().nullsLast().op("uuid_ops")),
+  foreignKey({
+    columns: [table.createdBy],
+    foreignColumns: [user.id],
+    name: "api_keys_created_by_user_id_fk"
+  }).onDelete("cascade"),
+  foreignKey({
+    columns: [table.tenantId],
+    foreignColumns: [tenants.id],
+    name: "api_keys_tenant_id_tenants_id_fk"
+  }).onDelete("cascade")
+]);
+var invitations = pgTable("invitations", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  tenantId: uuid("tenant_id").notNull(),
+  email: text().notNull(),
+  role: text("role", { enum: ["owner", "admin", "developer", "member"] }).default("member").notNull(),
+  token: text().notNull(),
+  invitedBy: text("invited_by").notNull(),
+  status: text("status", { enum: ["pending", "accepted", "declined", "cancelled"] }).default("pending").notNull(),
+  expiresAt: timestamp("expires_at").notNull(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  acceptedAt: timestamp("accepted_at")
+}, (table) => [
+  index("invitations_email_idx").using("btree", table.email.asc().nullsLast().op("text_ops")),
+  index("invitations_tenantId_idx").using("btree", table.tenantId.asc().nullsLast().op("uuid_ops")),
+  foreignKey({
+    columns: [table.invitedBy],
+    foreignColumns: [user.id],
+    name: "invitations_invited_by_user_id_fk"
+  }).onDelete("cascade"),
+  foreignKey({
+    columns: [table.tenantId],
+    foreignColumns: [tenants.id],
+    name: "invitations_tenant_id_tenants_id_fk"
+  }).onDelete("cascade"),
+  unique("invitations_token_unique").on(table.token)
+]);
+var runbooks = pgTable("runbooks", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  tenantId: uuid("tenant_id").notNull(),
+  title: text().notNull(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()).notNull(),
+  createdBy: text("created_by"),
+  activeVersionId: uuid("active_version_id"),
+  disabled: boolean().default(false).notNull()
+}, (table) => [
+  index("runbooks_createdAt_idx").using("btree", table.createdAt.asc().nullsLast().op("timestamp_ops")),
+  index("runbooks_tenantId_idx").using("btree", table.tenantId.asc().nullsLast().op("uuid_ops")),
+  foreignKey({
+    columns: [table.createdBy],
+    foreignColumns: [user.id],
+    name: "runbooks_created_by_user_id_fk"
+  }).onDelete("set null"),
+  foreignKey({
+    columns: [table.tenantId],
+    foreignColumns: [tenants.id],
+    name: "runbooks_tenant_id_tenants_id_fk"
+  }).onDelete("cascade")
+]);
+var runbookVersions = pgTable("runbook_versions", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  runbookId: uuid("runbook_id").notNull(),
+  versionNumber: integer("version_number").notNull(),
+  status: text("status", { enum: ["draft", "pending_verification", "pending_approval", "active", "archived"] }).default("draft").notNull(),
+  goal: text().notNull(),
+  startUrl: text("start_url"),
+  context: text(),
+  generatedAt: text("generated_at"),
+  verificationJobId: uuid("verification_job_id"),
+  createdBy: text("created_by"),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()).notNull(),
+  publishedAt: timestamp("published_at"),
+  publishedBy: text("published_by"),
+  changeDescription: text("change_description")
+}, (table) => [
+  index("runbook_versions_runbookId_idx").using("btree", table.runbookId.asc().nullsLast().op("uuid_ops")),
+  uniqueIndex("runbook_versions_runbookId_versionNumber_idx").using("btree", table.runbookId.asc().nullsLast().op("uuid_ops"), table.versionNumber.asc().nullsLast().op("int4_ops")),
+  index("runbook_versions_status_idx").using("btree", table.status.asc().nullsLast().op("text_ops")),
+  foreignKey({
+    columns: [table.createdBy],
+    foreignColumns: [user.id],
+    name: "runbook_versions_created_by_user_id_fk"
+  }).onDelete("set null"),
+  foreignKey({
+    columns: [table.publishedBy],
+    foreignColumns: [user.id],
+    name: "runbook_versions_published_by_user_id_fk"
+  }).onDelete("set null"),
+  foreignKey({
+    columns: [table.runbookId],
+    foreignColumns: [runbooks.id],
+    name: "runbook_versions_runbook_id_runbooks_id_fk"
+  }).onDelete("cascade")
+]);
+var schedules = pgTable("schedules", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  tenantId: uuid("tenant_id").notNull(),
+  runbookId: uuid("runbook_id").notNull(),
+  cron: text(),
+  enabled: boolean().default(true),
+  lastRunAt: timestamp("last_run_at"),
+  nextRunAt: timestamp("next_run_at"),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()).notNull(),
+  createdBy: text("created_by"),
+  type: text("type", { enum: ["recurring", "once"] }).default("recurring").notNull(),
+  timezone: text().default("UTC").notNull(),
+  scheduledAt: timestamp("scheduled_at"),
+  purpose: text("purpose", { enum: ["execute", "self_heal"] }).default("execute").notNull()
+}, (table) => [
+  index("schedules_nextRunAt_idx").using("btree", table.nextRunAt.asc().nullsLast().op("timestamp_ops")),
+  index("schedules_runbookId_idx").using("btree", table.runbookId.asc().nullsLast().op("uuid_ops")),
+  index("schedules_tenantId_idx").using("btree", table.tenantId.asc().nullsLast().op("uuid_ops")),
+  foreignKey({
+    columns: [table.createdBy],
+    foreignColumns: [user.id],
+    name: "schedules_created_by_user_id_fk"
+  }),
+  foreignKey({
+    columns: [table.runbookId],
+    foreignColumns: [runbooks.id],
+    name: "schedules_runbook_id_runbooks_id_fk"
+  }).onDelete("cascade"),
+  foreignKey({
+    columns: [table.tenantId],
+    foreignColumns: [tenants.id],
+    name: "schedules_tenant_id_tenants_id_fk"
+  }).onDelete("cascade")
+]);
+var jobs = pgTable("jobs", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  tenantId: uuid("tenant_id").notNull(),
+  runbookId: uuid("runbook_id"),
+  status: text("status", { enum: ["scheduled", "queued", "running", "waiting_approval", "paused", "completed", "failed", "cancelled", "exploring", "reviewing"] }).default("queued").notNull(),
+  currentStep: integer("current_step").default(0),
+  totalSteps: integer("total_steps").default(0).notNull(),
+  errorMessage: text("error_message"),
+  startedAt: timestamp("started_at"),
+  completedAt: timestamp("completed_at"),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  createdBy: text("created_by"),
+  purpose: text("purpose", { enum: ["verification", "scheduled", "manual", "api", "generation"] }).default("manual").notNull(),
+  mode: text("mode", { enum: ["execute", "self_heal", "generate"] }).default("execute").notNull(),
+  startUrl: text("start_url"),
+  goal: text(),
+  context: text(),
+  adoptedRunbookId: uuid("adopted_runbook_id"),
+  scheduledAt: timestamp("scheduled_at"),
+  scheduleId: uuid("schedule_id"),
+  runbookVersionId: uuid("runbook_version_id")
+}, (table) => [
+  index("jobs_createdAt_idx").using("btree", table.createdAt.asc().nullsLast().op("timestamp_ops")),
+  index("jobs_mode_idx").using("btree", table.mode.asc().nullsLast().op("text_ops")),
+  index("jobs_runbookId_idx").using("btree", table.runbookId.asc().nullsLast().op("uuid_ops")),
+  index("jobs_scheduleId_idx").using("btree", table.scheduleId.asc().nullsLast().op("uuid_ops")),
+  index("jobs_status_idx").using("btree", table.status.asc().nullsLast().op("text_ops")),
+  index("jobs_tenantId_idx").using("btree", table.tenantId.asc().nullsLast().op("uuid_ops")),
+  foreignKey({
+    columns: [table.adoptedRunbookId],
+    foreignColumns: [runbooks.id],
+    name: "jobs_adopted_runbook_id_runbooks_id_fk"
+  }),
+  foreignKey({
+    columns: [table.createdBy],
+    foreignColumns: [user.id],
+    name: "jobs_created_by_user_id_fk"
+  }).onDelete("set null"),
+  foreignKey({
+    columns: [table.runbookId],
+    foreignColumns: [runbooks.id],
+    name: "jobs_runbook_id_runbooks_id_fk"
+  }).onDelete("cascade"),
+  foreignKey({
+    columns: [table.runbookVersionId],
+    foreignColumns: [runbookVersions.id],
+    name: "jobs_runbook_version_id_runbook_versions_id_fk"
+  }).onDelete("set null"),
+  foreignKey({
+    columns: [table.scheduleId],
+    foreignColumns: [schedules.id],
+    name: "jobs_schedule_id_schedules_id_fk"
+  }).onDelete("set null"),
+  foreignKey({
+    columns: [table.tenantId],
+    foreignColumns: [tenants.id],
+    name: "jobs_tenant_id_tenants_id_fk"
+  }).onDelete("cascade")
+]);
+var jobAiMetrics = pgTable("job_ai_metrics", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  jobId: uuid("job_id").notNull(),
+  totalCalls: integer("total_calls").default(0).notNull(),
+  totalInputTokens: integer("total_input_tokens").default(0).notNull(),
+  totalOutputTokens: integer("total_output_tokens").default(0).notNull(),
+  totalCachedInputTokens: integer("total_cached_input_tokens").default(0).notNull(),
+  totalCacheCreationTokens: integer("total_cache_creation_tokens").default(0).notNull(),
+  cacheHitRate: real("cache_hit_rate").default(0).notNull(),
+  estimatedCostUsd: real("estimated_cost_usd").default(0).notNull(),
+  totalDurationMs: integer("total_duration_ms").default(0).notNull()
+}, (table) => [
+  foreignKey({
+    columns: [table.jobId],
+    foreignColumns: [jobs.id],
+    name: "job_ai_metrics_job_id_jobs_id_fk"
+  }).onDelete("cascade"),
+  unique("job_ai_metrics_job_id_unique").on(table.jobId)
+]);
+var jobApprovalRequests = pgTable("job_approval_requests", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  jobId: uuid("job_id").notNull(),
+  stepOrdinal: integer("step_ordinal").notNull(),
+  stepDescription: text("step_description"),
+  riskLevel: text("risk_level", { enum: ["low", "medium", "high"] }),
+  status: text("status", { enum: ["pending", "approved", "skipped", "aborted", "timeout"] }).default("pending").notNull(),
+  respondedBy: text("responded_by"),
+  respondedAt: timestamp("responded_at"),
+  createdAt: timestamp("created_at").defaultNow().notNull()
+}, (table) => [
+  index("job_approval_requests_jobId_idx").using("btree", table.jobId.asc().nullsLast().op("uuid_ops")),
+  uniqueIndex("job_approval_requests_jobId_step_idx").using("btree", table.jobId.asc().nullsLast().op("int4_ops"), table.stepOrdinal.asc().nullsLast().op("int4_ops")),
+  foreignKey({
+    columns: [table.jobId],
+    foreignColumns: [jobs.id],
+    name: "job_approval_requests_job_id_jobs_id_fk"
+  }).onDelete("cascade"),
+  foreignKey({
+    columns: [table.respondedBy],
+    foreignColumns: [user.id],
+    name: "job_approval_requests_responded_by_user_id_fk"
+  })
+]);
+var jobArtifacts = pgTable("job_artifacts", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  jobId: uuid("job_id").notNull(),
+  tenantId: uuid("tenant_id").notNull(),
+  type: text("type", { enum: ["screenshot", "video", "download", "export"] }).notNull(),
+  filename: text().notNull(),
+  storagePath: text("storage_path").notNull(),
+  contentType: text("content_type").notNull(),
+  sizeBytes: integer("size_bytes").notNull(),
+  stepOrdinal: integer("step_ordinal"),
+  createdAt: timestamp("created_at").defaultNow().notNull()
+}, (table) => [
+  index("job_artifacts_job_id_idx").using("btree", table.jobId.asc().nullsLast().op("uuid_ops")),
+  index("job_artifacts_tenant_type_idx").using("btree", table.tenantId.asc().nullsLast().op("text_ops"), table.type.asc().nullsLast().op("text_ops")),
+  foreignKey({
+    columns: [table.jobId],
+    foreignColumns: [jobs.id],
+    name: "job_artifacts_job_id_jobs_id_fk"
+  }).onDelete("cascade"),
+  foreignKey({
+    columns: [table.tenantId],
+    foreignColumns: [tenants.id],
+    name: "job_artifacts_tenant_id_tenants_id_fk"
+  }).onDelete("cascade")
+]);
+var jobDebugSuggestions = pgTable("job_debug_suggestions", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  jobId: uuid("job_id").notNull(),
+  stepOrdinal: integer("step_ordinal"),
+  stepDescription: text("step_description"),
+  error: text(),
+  runbookFix: text("runbook_fix"),
+  contextFix: text("context_fix"),
+  severity: text(),
+  failureCategory: text("failure_category"),
+  suggestedStrategy: text("suggested_strategy")
+}, (table) => [
+  index("job_debug_suggestions_jobId_idx").using("btree", table.jobId.asc().nullsLast().op("uuid_ops")),
+  foreignKey({
+    columns: [table.jobId],
+    foreignColumns: [jobs.id],
+    name: "job_debug_suggestions_job_id_jobs_id_fk"
+  }).onDelete("cascade")
+]);
+var jobDebugWarnings = pgTable("job_debug_warnings", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  jobId: uuid("job_id").notNull(),
+  ordinal: integer().notNull(),
+  description: text(),
+  retryCount: integer("retry_count"),
+  threshold: integer()
+}, (table) => [
+  index("job_debug_warnings_jobId_idx").using("btree", table.jobId.asc().nullsLast().op("uuid_ops")),
+  foreignKey({
+    columns: [table.jobId],
+    foreignColumns: [jobs.id],
+    name: "job_debug_warnings_job_id_jobs_id_fk"
+  }).onDelete("cascade")
+]);
+var jobExecutionConfigs = pgTable("job_execution_configs", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  jobId: uuid("job_id").notNull(),
+  defaultTimeout: integer("default_timeout").notNull(),
+  pauseBetweenSteps: integer("pause_between_steps").notNull(),
+  stopOnError: boolean("stop_on_error").notNull(),
+  stepDelay: integer("step_delay"),
+  enableSelectorCache: boolean("enable_selector_cache").notNull(),
+  enableAgentFallback: boolean("enable_agent_fallback").notNull(),
+  enableVisionFallback: boolean("enable_vision_fallback").notNull(),
+  modelId: text("model_id"),
+  modelProvider: text("model_provider")
+}, (table) => [
+  foreignKey({
+    columns: [table.jobId],
+    foreignColumns: [jobs.id],
+    name: "job_execution_configs_job_id_jobs_id_fk"
+  }).onDelete("cascade"),
+  unique("job_execution_configs_job_id_unique").on(table.jobId)
+]);
+var jobGenerateConfigs = pgTable("job_generate_configs", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  jobId: uuid("job_id").notNull(),
+  maxIterations: integer("max_iterations").default(20).notNull(),
+  stepDelay: integer("step_delay").default(500).notNull(),
+  headless: boolean().default(true).notNull(),
+  snapshotFilter: boolean("snapshot_filter").default(true).notNull(),
+  stallCheckInterval: integer("stall_check_interval").default(3).notNull(),
+  historyWindow: integer("history_window").default(10).notNull(),
+  maxConsecutiveFailures: integer("max_consecutive_failures").default(3).notNull(),
+  screenshotDir: text("screenshot_dir"),
+  videoDir: text("video_dir"),
+  stealth: boolean().default(false).notNull(),
+  proxy: text(),
+  modelId: text("model_id"),
+  modelProvider: text("model_provider"),
+  skills: text().array()
+}, (table) => [
+  foreignKey({
+    columns: [table.jobId],
+    foreignColumns: [jobs.id],
+    name: "job_generate_configs_job_id_jobs_id_fk"
+  }).onDelete("cascade"),
+  unique("job_generate_configs_job_id_unique").on(table.jobId)
+]);
+var jobRecordedSteps = pgTable("job_recorded_steps", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  jobId: uuid("job_id").notNull(),
+  ordinal: integer().notNull(),
+  actionType: text("action_type").notNull(),
+  selector: text(),
+  value: text(),
+  description: text(),
+  inputCategory: text("input_category"),
+  variableName: text("variable_name"),
+  url: text(),
+  success: boolean(),
+  error: text(),
+  screenshotPath: text("screenshot_path"),
+  failureCategory: text("failure_category"),
+  durationMs: integer("duration_ms"),
+  snapshotBefore: text("snapshot_before"),
+  suggestedCaptures: jsonb("suggested_captures"),
+  script: text(),
+  extractPrompt: text("extract_prompt"),
+  memoryCollection: text("memory_collection"),
+  aggregation: jsonb(),
+  downloadPath: text("download_path"),
+  exportCollection: text("export_collection"),
+  exportFormat: text("export_format"),
+  exportPath: text("export_path"),
+  keys: text()
+}, (table) => [
+  index("job_recorded_steps_jobId_idx").using("btree", table.jobId.asc().nullsLast().op("uuid_ops")),
+  uniqueIndex("job_recorded_steps_jobId_ordinal_idx").using("btree", table.jobId.asc().nullsLast().op("int4_ops"), table.ordinal.asc().nullsLast().op("int4_ops")),
+  foreignKey({
+    columns: [table.jobId],
+    foreignColumns: [jobs.id],
+    name: "job_recorded_steps_job_id_jobs_id_fk"
+  }).onDelete("cascade")
+]);
+var jobResults = pgTable("job_results", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  jobId: uuid("job_id").notNull(),
+  ordinal: integer().notNull(),
+  description: text().notNull(),
+  status: text("status", { enum: ["success", "failed", "skipped"] }).notNull(),
+  durationMs: integer("duration_ms").notNull(),
+  error: text(),
+  actionType: text("action_type"),
+  retryCount: integer("retry_count").default(0),
+  failureCategory: text("failure_category"),
+  capturedValues: jsonb("captured_values"),
+  conditionSkipped: boolean("condition_skipped").default(false),
+  loopIterations: integer("loop_iterations"),
+  branchMatch: text("branch_match"),
+  forEachItemCount: integer("for_each_item_count"),
+  extractedData: text("extracted_data"),
+  downloadedFile: text("downloaded_file"),
+  exportedFile: text("exported_file"),
+  createdAt: timestamp("created_at").defaultNow().notNull()
+}, (table) => [
+  index("job_results_jobId_idx").using("btree", table.jobId.asc().nullsLast().op("uuid_ops")),
+  uniqueIndex("job_results_jobId_ordinal_idx").using("btree", table.jobId.asc().nullsLast().op("int4_ops"), table.ordinal.asc().nullsLast().op("int4_ops")),
+  foreignKey({
+    columns: [table.jobId],
+    foreignColumns: [jobs.id],
+    name: "job_results_job_id_jobs_id_fk"
+  }).onDelete("cascade")
+]);
+var jobResultDiagnostics = pgTable("job_result_diagnostics", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  jobResultId: uuid("job_result_id").notNull(),
+  lastSnapshotPreview: text("last_snapshot_preview"),
+  failureHistory: jsonb("failure_history"),
+  lastAiResponseText: text("last_ai_response_text"),
+  recoveryHint: text("recovery_hint"),
+  deterministicResolveResult: text("deterministic_resolve_result"),
+  visionFallbackResult: jsonb("vision_fallback_result"),
+  agentFallbackResult: jsonb("agent_fallback_result"),
+  validationWarnings: jsonb("validation_warnings"),
+  validationErrors: jsonb("validation_errors"),
+  stepUrl: text("step_url")
+}, (table) => [
+  foreignKey({
+    columns: [table.jobResultId],
+    foreignColumns: [jobResults.id],
+    name: "job_result_diagnostics_job_result_id_job_results_id_fk"
+  }).onDelete("cascade"),
+  unique("job_result_diagnostics_job_result_id_unique").on(table.jobResultId)
+]);
+var jobReviewResults = pgTable("job_review_results", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  jobId: uuid("job_id").notNull(),
+  summary: text(),
+  yamlContent: text("yaml_content"),
+  goalAchieved: boolean("goal_achieved")
+}, (table) => [
+  foreignKey({
+    columns: [table.jobId],
+    foreignColumns: [jobs.id],
+    name: "job_review_results_job_id_jobs_id_fk"
+  }).onDelete("cascade"),
+  unique("job_review_results_job_id_unique").on(table.jobId)
+]);
+var jobReviewedSteps = pgTable("job_reviewed_steps", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  reviewResultId: uuid("review_result_id").notNull(),
+  originalOrdinal: integer("original_ordinal").notNull(),
+  keep: boolean().notNull(),
+  removalReason: text("removal_reason"),
+  riskLevel: text("risk_level"),
+  requiresConfirmation: boolean("requires_confirmation"),
+  confirmationReason: text("confirmation_reason")
+}, (table) => [
+  index("job_reviewed_steps_reviewResultId_idx").using("btree", table.reviewResultId.asc().nullsLast().op("uuid_ops")),
+  foreignKey({
+    columns: [table.reviewResultId],
+    foreignColumns: [jobReviewResults.id],
+    name: "job_reviewed_steps_review_result_id_job_review_results_id_fk"
+  }).onDelete("cascade")
+]);
+var jobVariables = pgTable("job_variables", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  jobId: uuid("job_id").notNull(),
+  key: text().notNull(),
+  value: text().notNull(),
+  sensitive: boolean().default(false).notNull()
+}, (table) => [
+  uniqueIndex("job_variables_jobId_key_idx").using("btree", table.jobId.asc().nullsLast().op("text_ops"), table.key.asc().nullsLast().op("text_ops")),
+  foreignKey({
+    columns: [table.jobId],
+    foreignColumns: [jobs.id],
+    name: "job_variables_job_id_jobs_id_fk"
+  }).onDelete("cascade")
+]);
+var runbookSecrets = pgTable("runbook_secrets", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  key: text().notNull(),
+  encryptedValue: text("encrypted_value").notNull(),
+  versionId: uuid("version_id").notNull()
+}, (table) => [
+  uniqueIndex("runbook_secrets_versionId_key_idx").using("btree", table.versionId.asc().nullsLast().op("text_ops"), table.key.asc().nullsLast().op("text_ops")),
+  foreignKey({
+    columns: [table.versionId],
+    foreignColumns: [runbookVersions.id],
+    name: "runbook_secrets_version_id_runbook_versions_id_fk"
+  }).onDelete("cascade")
+]);
+var runbookSettings = pgTable("runbook_settings", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  defaultTimeout: integer("default_timeout"),
+  pauseBetweenSteps: integer("pause_between_steps"),
+  stopOnError: boolean("stop_on_error"),
+  stepDelay: integer("step_delay"),
+  enableSelectorCache: boolean("enable_selector_cache"),
+  enableAgentFallback: boolean("enable_agent_fallback"),
+  enableVisionFallback: boolean("enable_vision_fallback"),
+  modelId: text("model_id"),
+  modelProvider: text("model_provider"),
+  selfHealEnabled: boolean("self_heal_enabled").default(false).notNull(),
+  versionId: uuid("version_id").notNull()
+}, (table) => [
+  foreignKey({
+    columns: [table.versionId],
+    foreignColumns: [runbookVersions.id],
+    name: "runbook_settings_version_id_runbook_versions_id_fk"
+  }).onDelete("cascade"),
+  unique("runbook_settings_version_id_unique").on(table.versionId)
+]);
+var runbookSteps = pgTable("runbook_steps", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  parentStepId: uuid("parent_step_id"),
+  ordinal: integer().notNull(),
+  description: text().notNull(),
+  actionType: text("action_type", { enum: ["click", "input", "select", "navigate", "scroll", "wait", "hover", "extract", "download", "export", "memory", "key"] }).notNull(),
+  url: text(),
+  riskLevel: text("risk_level", { enum: ["low", "medium", "high"] }).default("low").notNull(),
+  requiresConfirmation: boolean("requires_confirmation").default(false).notNull(),
+  value: text(),
+  optionText: text("option_text"),
+  script: text(),
+  keys: text(),
+  downloadPath: text("download_path"),
+  exportCollection: text("export_collection"),
+  exportFormat: text("export_format"),
+  exportPath: text("export_path"),
+  selector: jsonb(),
+  condition: text(),
+  captures: jsonb(),
+  memoryOperations: jsonb("memory_operations"),
+  loopCondition: text("loop_condition"),
+  loopForEach: text("loop_for_each"),
+  loopItemVariable: text("loop_item_variable"),
+  loopIndexVariable: text("loop_index_variable"),
+  loopMaxIterations: integer("loop_max_iterations"),
+  loopCounterVariable: text("loop_counter_variable"),
+  branchValue: text("branch_value"),
+  branchCaseMatch: text("branch_case_match"),
+  branchIsDefault: boolean("branch_is_default").default(false),
+  versionId: uuid("version_id").notNull()
+}, (table) => [
+  index("runbook_steps_parentStepId_idx").using("btree", table.parentStepId.asc().nullsLast().op("uuid_ops")),
+  index("runbook_steps_versionId_idx").using("btree", table.versionId.asc().nullsLast().op("uuid_ops")),
+  foreignKey({
+    columns: [table.versionId],
+    foreignColumns: [runbookVersions.id],
+    name: "runbook_steps_version_id_runbook_versions_id_fk"
+  }).onDelete("cascade")
+]);
+var runbookVariables = pgTable("runbook_variables", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  name: text().notNull(),
+  source: text("source", { enum: ["prompt", "fixed", "context", "env", "expression", "data"] }).notNull(),
+  description: text(),
+  required: boolean().default(false).notNull(),
+  sensitive: boolean().default(false).notNull(),
+  value: text(),
+  versionId: uuid("version_id").notNull()
+}, (table) => [
+  index("runbook_variables_versionId_idx").using("btree", table.versionId.asc().nullsLast().op("uuid_ops")),
+  uniqueIndex("runbook_variables_versionId_name_idx").using("btree", table.versionId.asc().nullsLast().op("text_ops"), table.name.asc().nullsLast().op("text_ops")),
+  foreignKey({
+    columns: [table.versionId],
+    foreignColumns: [runbookVersions.id],
+    name: "runbook_variables_version_id_runbook_versions_id_fk"
+  }).onDelete("cascade")
+]);
+var runbookVersionReviews = pgTable("runbook_version_reviews", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  versionId: uuid("version_id").notNull(),
+  requestedBy: text("requested_by").notNull(),
+  requestedAt: timestamp("requested_at").defaultNow().notNull(),
+  reviewerId: text("reviewer_id"),
+  reviewedAt: timestamp("reviewed_at"),
+  status: text("status", { enum: ["pending", "approved", "rejected"] }).default("pending").notNull(),
+  comment: text()
+}, (table) => [
+  index("runbook_version_reviews_status_idx").using("btree", table.status.asc().nullsLast().op("text_ops")),
+  index("runbook_version_reviews_versionId_idx").using("btree", table.versionId.asc().nullsLast().op("uuid_ops")),
+  foreignKey({
+    columns: [table.requestedBy],
+    foreignColumns: [user.id],
+    name: "runbook_version_reviews_requested_by_user_id_fk"
+  }).onDelete("cascade"),
+  foreignKey({
+    columns: [table.reviewerId],
+    foreignColumns: [user.id],
+    name: "runbook_version_reviews_reviewer_id_user_id_fk"
+  }).onDelete("set null"),
+  foreignKey({
+    columns: [table.versionId],
+    foreignColumns: [runbookVersions.id],
+    name: "runbook_version_reviews_version_id_runbook_versions_id_fk"
+  }).onDelete("cascade")
+]);
+var session = pgTable("session", {
+  id: text().primaryKey().notNull(),
+  expiresAt: timestamp("expires_at").notNull(),
+  token: text().notNull(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()).notNull(),
+  ipAddress: text("ip_address"),
+  userAgent: text("user_agent"),
+  userId: text("user_id").notNull()
+}, (table) => [
+  index("session_userId_idx").using("btree", table.userId.asc().nullsLast().op("text_ops")),
+  foreignKey({
+    columns: [table.userId],
+    foreignColumns: [user.id],
+    name: "session_user_id_user_id_fk"
+  }).onDelete("cascade"),
+  unique("session_token_unique").on(table.token)
+]);
+var telemetryFailureEvents = pgTable("telemetry_failure_events", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  tenantId: uuid("tenant_id").notNull(),
+  jobId: uuid("job_id").notNull(),
+  runbookId: uuid("runbook_id"),
+  stepOrdinal: integer("step_ordinal").notNull(),
+  urlPattern: text("url_pattern").notNull(),
+  selectorHint: text("selector_hint").notNull(),
+  failureCategory: text("failure_category").notNull(),
+  actionType: text("action_type"),
+  stepDescription: text("step_description"),
+  stepAction: jsonb("step_action"),
+  errorMessage: text("error_message"),
+  failureHistory: jsonb("failure_history"),
+  retryCount: integer("retry_count").default(0),
+  retryDetails: jsonb("retry_details"),
+  snapshotPreview: text("snapshot_preview"),
+  stepUrl: text("step_url"),
+  deterministicResult: text("deterministic_result"),
+  visionFallback: jsonb("vision_fallback"),
+  agentFallback: jsonb("agent_fallback"),
+  resolveMethod: text("resolve_method"),
+  contextChunksUsed: integer("context_chunks_used"),
+  failureHintsInjected: text("failure_hints_injected"),
+  validationWarnings: jsonb("validation_warnings"),
+  validationErrors: jsonb("validation_errors"),
+  executionStrategy: jsonb("execution_strategy"),
+  durationMs: integer("duration_ms"),
+  recoveryHint: text("recovery_hint"),
+  createdAt: timestamp("created_at").defaultNow().notNull()
+}, (table) => [
+  index("telemetry_failure_events_tenant_category_idx").using("btree", table.tenantId.asc().nullsLast().op("uuid_ops"), table.failureCategory.asc().nullsLast().op("uuid_ops")),
+  index("telemetry_failure_events_tenant_created_idx").using("btree", table.tenantId.asc().nullsLast().op("uuid_ops"), table.createdAt.asc().nullsLast().op("uuid_ops")),
+  index("telemetry_failure_events_tenant_pattern_idx").using("btree", table.tenantId.asc().nullsLast().op("text_ops"), table.urlPattern.asc().nullsLast().op("uuid_ops"), table.selectorHint.asc().nullsLast().op("text_ops")),
+  index("telemetry_failure_events_tenant_runbook_idx").using("btree", table.tenantId.asc().nullsLast().op("uuid_ops"), table.runbookId.asc().nullsLast().op("uuid_ops")),
+  foreignKey({
+    columns: [table.jobId],
+    foreignColumns: [jobs.id],
+    name: "telemetry_failure_events_job_id_jobs_id_fk"
+  }).onDelete("cascade"),
+  foreignKey({
+    columns: [table.runbookId],
+    foreignColumns: [runbooks.id],
+    name: "telemetry_failure_events_runbook_id_runbooks_id_fk"
+  }).onDelete("set null"),
+  foreignKey({
+    columns: [table.tenantId],
+    foreignColumns: [tenants.id],
+    name: "telemetry_failure_events_tenant_id_tenants_id_fk"
+  }).onDelete("cascade")
+]);
+var telemetryFailurePatterns = pgTable("telemetry_failure_patterns", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  tenantId: uuid("tenant_id").notNull(),
+  runbookId: uuid("runbook_id"),
+  urlPattern: text("url_pattern").notNull(),
+  selectorHint: text("selector_hint").notNull(),
+  failureCategory: text("failure_category").notNull(),
+  occurrenceCount: integer("occurrence_count").default(1).notNull(),
+  lastErrorMessage: text("last_error_message"),
+  lastSnapshotExcerpt: text("last_snapshot_excerpt"),
+  successfulRecoveries: jsonb("successful_recoveries"),
+  lastRecoveryMethod: text("last_recovery_method"),
+  lastJobId: uuid("last_job_id"),
+  lastStepOrdinal: integer("last_step_ordinal"),
+  firstSeenAt: timestamp("first_seen_at").defaultNow().notNull(),
+  lastSeenAt: timestamp("last_seen_at").defaultNow().notNull()
+}, (table) => [
+  index("telemetry_failure_patterns_tenant_category_idx").using("btree", table.tenantId.asc().nullsLast().op("text_ops"), table.failureCategory.asc().nullsLast().op("text_ops")),
+  index("telemetry_failure_patterns_tenant_runbook_idx").using("btree", table.tenantId.asc().nullsLast().op("uuid_ops"), table.runbookId.asc().nullsLast().op("uuid_ops")),
+  uniqueIndex("telemetry_failure_patterns_unique_idx").using("btree", table.tenantId.asc().nullsLast().op("text_ops"), table.urlPattern.asc().nullsLast().op("uuid_ops"), table.selectorHint.asc().nullsLast().op("text_ops"), table.failureCategory.asc().nullsLast().op("text_ops")),
+  foreignKey({
+    columns: [table.runbookId],
+    foreignColumns: [runbooks.id],
+    name: "telemetry_failure_patterns_runbook_id_runbooks_id_fk"
+  }).onDelete("set null"),
+  foreignKey({
+    columns: [table.tenantId],
+    foreignColumns: [tenants.id],
+    name: "telemetry_failure_patterns_tenant_id_tenants_id_fk"
+  }).onDelete("cascade")
+]);
+var telemetryJobSummaries = pgTable("telemetry_job_summaries", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  tenantId: uuid("tenant_id").notNull(),
+  jobId: uuid("job_id").notNull(),
+  runbookId: uuid("runbook_id"),
+  runbookContentHash: text("runbook_content_hash"),
+  mode: text(),
+  totalSteps: integer("total_steps"),
+  succeededSteps: integer("succeeded_steps"),
+  failedSteps: integer("failed_steps"),
+  skippedSteps: integer("skipped_steps"),
+  aborted: boolean(),
+  totalDurationMs: integer("total_duration_ms"),
+  failureCategoryCounts: jsonb("failure_category_counts"),
+  retryDistribution: jsonb("retry_distribution"),
+  resolveMethodCounts: jsonb("resolve_method_counts"),
+  stepsWithRetries: integer("steps_with_retries").default(0),
+  totalRetryCount: integer("total_retry_count").default(0),
+  visionFallbackAttempts: integer("vision_fallback_attempts").default(0),
+  visionFallbackSuccesses: integer("vision_fallback_successes").default(0),
+  agentFallbackAttempts: integer("agent_fallback_attempts").default(0),
+  agentFallbackSuccesses: integer("agent_fallback_successes").default(0),
+  slowStepsCount: integer("slow_steps_count").default(0),
+  maxStepDurationMs: integer("max_step_duration_ms").default(0),
+  aiTotalCalls: integer("ai_total_calls").default(0),
+  aiTotalInputTokens: integer("ai_total_input_tokens").default(0),
+  aiTotalOutputTokens: integer("ai_total_output_tokens").default(0),
+  aiCacheHitRate: real("ai_cache_hit_rate").default(0),
+  aiEstimatedCostUsd: real("ai_estimated_cost_usd").default(0),
+  aiTotalDurationMs: integer("ai_total_duration_ms").default(0),
+  modelId: text("model_id"),
+  modelProvider: text("model_provider"),
+  createdAt: timestamp("created_at").defaultNow().notNull()
+}, (table) => [
+  index("telemetry_job_summaries_runbookId_idx").using("btree", table.runbookId.asc().nullsLast().op("uuid_ops")),
+  index("telemetry_job_summaries_tenantId_idx").using("btree", table.tenantId.asc().nullsLast().op("uuid_ops")),
+  index("telemetry_job_summaries_tenant_created_idx").using("btree", table.tenantId.asc().nullsLast().op("timestamp_ops"), table.createdAt.asc().nullsLast().op("uuid_ops")),
+  foreignKey({
+    columns: [table.jobId],
+    foreignColumns: [jobs.id],
+    name: "telemetry_job_summaries_job_id_jobs_id_fk"
+  }).onDelete("cascade"),
+  foreignKey({
+    columns: [table.runbookId],
+    foreignColumns: [runbooks.id],
+    name: "telemetry_job_summaries_runbook_id_runbooks_id_fk"
+  }).onDelete("set null"),
+  foreignKey({
+    columns: [table.tenantId],
+    foreignColumns: [tenants.id],
+    name: "telemetry_job_summaries_tenant_id_tenants_id_fk"
+  }).onDelete("cascade"),
+  unique("telemetry_job_summaries_job_id_unique").on(table.jobId)
+]);
+var telemetryResolutionOutcomes = pgTable("telemetry_resolution_outcomes", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  tenantId: uuid("tenant_id").notNull(),
+  jobId: uuid("job_id").notNull(),
+  runbookId: uuid("runbook_id"),
+  stepOrdinal: integer("step_ordinal").notNull(),
+  status: text().notNull(),
+  resolveMethod: text("resolve_method"),
+  retryCount: integer("retry_count").default(0),
+  durationMs: integer("duration_ms"),
+  deterministicMatchType: text("deterministic_match_type"),
+  deterministicConfidence: real("deterministic_confidence"),
+  urlPattern: text("url_pattern"),
+  selectorHint: text("selector_hint"),
+  actionType: text("action_type"),
+  aiReasoning: text("ai_reasoning"),
+  contextChunksUsed: integer("context_chunks_used").default(0),
+  workingMemoryTokens: integer("working_memory_tokens").default(0),
+  failureHintsProvided: boolean("failure_hints_provided").default(false),
+  snapshotElementCount: integer("snapshot_element_count").default(0),
+  createdAt: timestamp("created_at").defaultNow().notNull()
+}, (table) => [
+  index("telemetry_resolution_outcomes_tenant_job_idx").using("btree", table.tenantId.asc().nullsLast().op("uuid_ops"), table.jobId.asc().nullsLast().op("uuid_ops")),
+  index("telemetry_resolution_outcomes_tenant_match_idx").using("btree", table.tenantId.asc().nullsLast().op("uuid_ops"), table.deterministicMatchType.asc().nullsLast().op("uuid_ops")),
+  index("telemetry_resolution_outcomes_tenant_method_idx").using("btree", table.tenantId.asc().nullsLast().op("text_ops"), table.resolveMethod.asc().nullsLast().op("text_ops")),
+  index("telemetry_resolution_outcomes_tenant_runbook_idx").using("btree", table.tenantId.asc().nullsLast().op("uuid_ops"), table.runbookId.asc().nullsLast().op("uuid_ops")),
+  foreignKey({
+    columns: [table.jobId],
+    foreignColumns: [jobs.id],
+    name: "telemetry_resolution_outcomes_job_id_jobs_id_fk"
+  }).onDelete("cascade"),
+  foreignKey({
+    columns: [table.runbookId],
+    foreignColumns: [runbooks.id],
+    name: "telemetry_resolution_outcomes_runbook_id_runbooks_id_fk"
+  }).onDelete("set null"),
+  foreignKey({
+    columns: [table.tenantId],
+    foreignColumns: [tenants.id],
+    name: "telemetry_resolution_outcomes_tenant_id_tenants_id_fk"
+  }).onDelete("cascade")
+]);
+var telemetrySuggestionOutcomes = pgTable("telemetry_suggestion_outcomes", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  tenantId: uuid("tenant_id").notNull(),
+  runbookId: uuid("runbook_id").notNull(),
+  suggestionJobId: uuid("suggestion_job_id").notNull(),
+  stepOrdinal: integer("step_ordinal"),
+  stepDescription: text("step_description"),
+  failureCategory: text("failure_category"),
+  suggestedStrategy: text("suggested_strategy"),
+  runbookFix: text("runbook_fix"),
+  contextFix: text("context_fix"),
+  severity: text(),
+  applied: boolean().default(false).notNull(),
+  appliedAt: timestamp("applied_at"),
+  verificationJobId: uuid("verification_job_id"),
+  verificationSuccess: boolean("verification_success"),
+  verificationError: text("verification_error"),
+  verifiedAt: timestamp("verified_at"),
+  createdAt: timestamp("created_at").defaultNow().notNull()
+}, (table) => [
+  index("telemetry_suggestion_outcomes_applied_verification_idx").using("btree", table.applied.asc().nullsLast().op("bool_ops"), table.verificationJobId.asc().nullsLast().op("uuid_ops")),
+  index("telemetry_suggestion_outcomes_tenant_job_idx").using("btree", table.tenantId.asc().nullsLast().op("uuid_ops"), table.suggestionJobId.asc().nullsLast().op("uuid_ops")),
+  index("telemetry_suggestion_outcomes_tenant_runbook_idx").using("btree", table.tenantId.asc().nullsLast().op("uuid_ops"), table.runbookId.asc().nullsLast().op("uuid_ops")),
+  foreignKey({
+    columns: [table.runbookId],
+    foreignColumns: [runbooks.id],
+    name: "telemetry_suggestion_outcomes_runbook_id_runbooks_id_fk"
+  }).onDelete("cascade"),
+  foreignKey({
+    columns: [table.suggestionJobId],
+    foreignColumns: [jobs.id],
+    name: "telemetry_suggestion_outcomes_suggestion_job_id_jobs_id_fk"
+  }).onDelete("cascade"),
+  foreignKey({
+    columns: [table.tenantId],
+    foreignColumns: [tenants.id],
+    name: "telemetry_suggestion_outcomes_tenant_id_tenants_id_fk"
+  }).onDelete("cascade")
+]);
+var tenantDevelopmentSettings = pgTable("tenant_development_settings", {
+  tenantId: uuid("tenant_id").primaryKey().notNull(),
+  requireApprovalBeforePublish: boolean("require_approval_before_publish").default(false).notNull(),
+  allowSelfApproval: boolean("allow_self_approval").default(false).notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()).notNull(),
+  updatedBy: text("updated_by")
+}, (table) => [
+  foreignKey({
+    columns: [table.tenantId],
+    foreignColumns: [tenants.id],
+    name: "tenant_development_settings_tenant_id_tenants_id_fk"
+  }).onDelete("cascade"),
+  foreignKey({
+    columns: [table.updatedBy],
+    foreignColumns: [user.id],
+    name: "tenant_development_settings_updated_by_user_id_fk"
+  }).onDelete("set null")
+]);
+var tenantExecutionConfigs = pgTable("tenant_execution_configs", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  tenantId: uuid("tenant_id").notNull(),
+  defaultTimeout: integer("default_timeout").default(3e4).notNull(),
+  pauseBetweenSteps: integer("pause_between_steps").default(500).notNull(),
+  stopOnError: boolean("stop_on_error").default(true).notNull(),
+  stepDelay: integer("step_delay"),
+  enableSelectorCache: boolean("enable_selector_cache").default(true).notNull(),
+  enableAgentFallback: boolean("enable_agent_fallback").default(true).notNull(),
+  enableVisionFallback: boolean("enable_vision_fallback").default(false).notNull(),
+  modelId: text("model_id"),
+  modelProvider: text("model_provider")
+}, (table) => [
+  foreignKey({
+    columns: [table.tenantId],
+    foreignColumns: [tenants.id],
+    name: "tenant_execution_configs_tenant_id_tenants_id_fk"
+  }).onDelete("cascade"),
+  unique("tenant_execution_configs_tenant_id_unique").on(table.tenantId)
+]);
+var tenantExecutionSettings = pgTable("tenant_execution_settings", {
+  tenantId: uuid("tenant_id").primaryKey().notNull(),
+  headless: boolean().default(true).notNull(),
+  stealth: boolean().default(false).notNull(),
+  proxy: text(),
+  approvalMode: text("approval_mode", { enum: ["web", "slack", "teams", "discord"] }).default("web").notNull(),
+  notifyMode: text("notify_mode", { enum: ["slack", "teams", "discord"] }),
+  enableSelectorCache: boolean("enable_selector_cache").default(true).notNull(),
+  enableAgentFallback: boolean("enable_agent_fallback").default(true).notNull(),
+  enableVisionFallback: boolean("enable_vision_fallback").default(false).notNull(),
+  skills: text().array().default([""]).notNull(),
+  apiKey: text("api_key"),
+  updatedAt: timestamp("updated_at").defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()).notNull(),
+  updatedBy: text("updated_by"),
+  notificationCredentials: jsonb("notification_credentials"),
+  enableScreenshots: boolean("enable_screenshots").default(false).notNull(),
+  enableVideoRecording: boolean("enable_video_recording").default(false).notNull()
+}, (table) => [
+  foreignKey({
+    columns: [table.tenantId],
+    foreignColumns: [tenants.id],
+    name: "tenant_execution_settings_tenant_id_tenants_id_fk"
+  }).onDelete("cascade"),
+  foreignKey({
+    columns: [table.updatedBy],
+    foreignColumns: [user.id],
+    name: "tenant_execution_settings_updated_by_user_id_fk"
+  })
+]);
+var tenantMembers = pgTable("tenant_members", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  tenantId: uuid("tenant_id").notNull(),
+  userId: text("user_id").notNull(),
+  role: text("role", { enum: ["owner", "admin", "developer", "member"] }).default("member").notNull(),
+  createdAt: timestamp("created_at").defaultNow().notNull()
+}, (table) => [
+  index("tenant_members_tenantId_idx").using("btree", table.tenantId.asc().nullsLast().op("uuid_ops")),
+  index("tenant_members_userId_idx").using("btree", table.userId.asc().nullsLast().op("text_ops")),
+  foreignKey({
+    columns: [table.tenantId],
+    foreignColumns: [tenants.id],
+    name: "tenant_members_tenant_id_tenants_id_fk"
+  }).onDelete("cascade"),
+  foreignKey({
+    columns: [table.userId],
+    foreignColumns: [user.id],
+    name: "tenant_members_user_id_user_id_fk"
+  }).onDelete("cascade")
+]);
+var tenantModelOverrides = pgTable("tenant_model_overrides", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  tenantId: uuid("tenant_id").notNull(),
+  purpose: text("purpose", { enum: ["selector", "extraction", "exploration", "exploration-light", "review", "fallback", "vision"] }).notNull(),
+  description: text().notNull(),
+  modelId: text("model_id").notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()).notNull()
+}, (table) => [
+  index("tenant_model_overrides_tenantId_idx").using("btree", table.tenantId.asc().nullsLast().op("uuid_ops")),
+  uniqueIndex("tenant_model_overrides_tenant_purpose_idx").using("btree", table.tenantId.asc().nullsLast().op("text_ops"), table.purpose.asc().nullsLast().op("text_ops")),
+  foreignKey({
+    columns: [table.tenantId],
+    foreignColumns: [tenants.id],
+    name: "tenant_model_overrides_tenant_id_tenants_id_fk"
+  }).onDelete("cascade")
+]);
+var tenantModelProviders = pgTable("tenant_model_providers", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  tenantId: uuid("tenant_id").notNull(),
+  providerId: text("provider_id", { enum: ["anthropic", "openai", "openai-compatible", "google", "azure", "bedrock", "vertex"] }).notNull(),
+  modelId: text("model_id").notNull(),
+  connected: boolean().default(false).notNull(),
+  config: jsonb().default({}).notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()).notNull()
+}, (table) => [
+  index("tenant_model_providers_tenantId_idx").using("btree", table.tenantId.asc().nullsLast().op("uuid_ops")),
+  uniqueIndex("tenant_model_providers_tenant_provider_idx").using("btree", table.tenantId.asc().nullsLast().op("text_ops"), table.providerId.asc().nullsLast().op("text_ops")),
+  foreignKey({
+    columns: [table.tenantId],
+    foreignColumns: [tenants.id],
+    name: "tenant_model_providers_tenant_id_tenants_id_fk"
+  }).onDelete("cascade")
+]);
+var tenantUsage = pgTable("tenant_usage", {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  tenantId: uuid("tenant_id").notNull(),
+  month: text().notNull(),
+  jobCount: integer("job_count").default(0).notNull(),
+  stepCount: integer("step_count").default(0).notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()).notNull()
+}, (table) => [
+  index("tenant_usage_tenantId_idx").using("btree", table.tenantId.asc().nullsLast().op("uuid_ops")),
+  uniqueIndex("tenant_usage_tenant_month_idx").using("btree", table.tenantId.asc().nullsLast().op("text_ops"), table.month.asc().nullsLast().op("text_ops")),
+  foreignKey({
+    columns: [table.tenantId],
+    foreignColumns: [tenants.id],
+    name: "tenant_usage_tenant_id_tenants_id_fk"
+  }).onDelete("cascade")
+]);
+
+export {
+  dataMigrationHistory,
+  verification,
+  tenants,
+  user,
+  account,
+  apiKeys,
+  invitations,
+  runbooks,
+  runbookVersions,
+  schedules,
+  jobs,
+  jobAiMetrics,
+  jobApprovalRequests,
+  jobArtifacts,
+  jobDebugSuggestions,
+  jobDebugWarnings,
+  jobExecutionConfigs,
+  jobGenerateConfigs,
+  jobRecordedSteps,
+  jobResults,
+  jobResultDiagnostics,
+  jobReviewResults,
+  jobReviewedSteps,
+  jobVariables,
+  runbookSecrets,
+  runbookSettings,
+  runbookSteps,
+  runbookVariables,
+  runbookVersionReviews,
+  session,
+  telemetryFailureEvents,
+  telemetryFailurePatterns,
+  telemetryJobSummaries,
+  telemetryResolutionOutcomes,
+  telemetrySuggestionOutcomes,
+  tenantDevelopmentSettings,
+  tenantExecutionConfigs,
+  tenantExecutionSettings,
+  tenantMembers,
+  tenantModelOverrides,
+  tenantModelProviders,
+  tenantUsage,
+  schema_exports
+};
+//# sourceMappingURL=chunk-CLYJHKPY.js.map