@rulemetric/cli 0.2.0 → 0.2.2

package/dist/chunk-7FAA3YNB.js

@@ -0,0 +1,1549 @@
+import {
+  __export
+} from "./chunk-NSBPE2FW.js";
+
+// ../../packages/db/dist/schema/tables/profiles.js
+import { boolean, pgTable as pgTable2, text as text2, timestamp as timestamp2, uuid as uuid2 } from "drizzle-orm/pg-core";
+
+// ../../packages/db/dist/schema/tables/organizations.js
+import { pgTable, text, timestamp, jsonb, uuid, primaryKey } from "drizzle-orm/pg-core";
+var organizations = pgTable("organizations", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  name: text("name").unique().notNull(),
+  slug: text("slug").unique().notNull(),
+  metadata: jsonb("metadata"),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow()
+});
+var teams = pgTable("teams", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  orgId: uuid("org_id").references(() => organizations.id, { onDelete: "cascade" }),
+  name: text("name").notNull(),
+  slug: text("slug").notNull(),
+  metadata: jsonb("metadata"),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow()
+});
+var userOrganizations = pgTable("user_organizations", {
+  userId: uuid("user_id").notNull(),
+  orgId: uuid("org_id").references(() => organizations.id, { onDelete: "cascade" }).notNull(),
+  role: text("role").notNull().default("member"),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.userId, table.orgId] })
+]);
+var userTeams = pgTable("user_teams", {
+  userId: uuid("user_id").notNull(),
+  teamId: uuid("team_id").references(() => teams.id, { onDelete: "cascade" }).notNull(),
+  role: text("role").notNull().default("member"),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.userId, table.teamId] })
+]);
+
+// ../../packages/db/dist/schema/tables/profiles.js
+var profiles = pgTable2("profiles", {
+  id: uuid2("id").primaryKey(),
+  email: text2("email"),
+  displayName: text2("display_name"),
+  avatarUrl: text2("avatar_url"),
+  activeOrgId: uuid2("active_org_id").references(() => organizations.id, { onDelete: "set null" }),
+  isSuperadmin: boolean("is_superadmin").notNull().default(false),
+  claudeCodePlan: text2("claude_code_plan"),
+  planSource: text2("plan_source").notNull().default("detected"),
+  setupCompletedAt: timestamp2("setup_completed_at", { withTimezone: true }),
+  liveSendSkipped: boolean("live_send_skipped").notNull().default(false),
+  createdAt: timestamp2("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp2("updated_at", { withTimezone: true }).defaultNow()
+});
+
+// ../../packages/db/dist/schema/tables/agent-runs.js
+import { pgTable as pgTable5, text as text5, timestamp as timestamp5, jsonb as jsonb4, uuid as uuid5, integer as integer2, boolean as boolean4, index as index2 } from "drizzle-orm/pg-core";
+
+// ../../packages/db/dist/schema/tables/projects.js
+import { boolean as boolean3, jsonb as jsonb3, pgTable as pgTable4, primaryKey as primaryKey2, text as text4, timestamp as timestamp4, uniqueIndex as uniqueIndex2, uuid as uuid4 } from "drizzle-orm/pg-core";
+import { sql } from "drizzle-orm";
+
+// ../../packages/db/dist/schema/tables/instructions.js
+import { pgTable as pgTable3, text as text3, timestamp as timestamp3, jsonb as jsonb2, uuid as uuid3, integer, boolean as boolean2, uniqueIndex, index } from "drizzle-orm/pg-core";
+var instructions = pgTable3("instructions", {
+  id: uuid3("id").primaryKey().defaultRandom(),
+  name: text3("name").notNull(),
+  description: text3("description").notNull(),
+  type: text3("type").notNull().default("instruction"),
+  scope: text3("scope").notNull(),
+  scopeRef: uuid3("scope_ref"),
+  version: text3("version").notNull(),
+  content: text3("content").notNull(),
+  frontmatter: jsonb2("frontmatter").notNull(),
+  slots: jsonb2("slots"),
+  tags: text3("tags").array(),
+  compatibility: text3("compatibility").array(),
+  createdBy: uuid3("created_by"),
+  createdAt: timestamp3("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp3("updated_at", { withTimezone: true }).defaultNow(),
+  archived: boolean2("archived").default(false),
+  archivedAt: timestamp3("archived_at", { withTimezone: true }),
+  archivedBy: uuid3("archived_by"),
+  forkedFromId: uuid3("forked_from_id").references(() => instructions.id, { onDelete: "set null" }),
+  upstreamVersion: text3("upstream_version"),
+  badge: text3("badge"),
+  contentHash: text3("content_hash"),
+  contextIdentity: text3("context_identity"),
+  scanScore: integer("scan_score"),
+  scanFindings: jsonb2("scan_findings"),
+  popularityScore: integer("popularity_score"),
+  // Source file's last git-commit date (from the skills registry). Distinct
+  // from updatedAt, which is the local row's last-sync time. Used to sort the
+  // public catalog by genuine recency. NULL for non-registry rows and until
+  // the next registry sync populates it.
+  sourceUpdatedAt: timestamp3("source_updated_at", { withTimezone: true })
+}, (table) => [
+  uniqueIndex("instructions_name_scope_ref_idx").on(table.name, table.scope, table.scopeRef),
+  index("idx_instructions_scope").on(table.scope, table.scopeRef),
+  index("idx_instructions_created_by").on(table.createdBy),
+  index("idx_instructions_context_identity").on(table.createdBy, table.contextIdentity),
+  // Recency sort for the public catalog: COALESCE(source_updated_at, updated_at) DESC.
+  index("idx_instructions_public_recency").on(table.scope, table.sourceUpdatedAt.desc())
+]);
+var instructionVersions = pgTable3("instruction_versions", {
+  id: uuid3("id").primaryKey().defaultRandom(),
+  instructionId: uuid3("instruction_id").references(() => instructions.id, { onDelete: "cascade" }),
+  versionNumber: integer("version_number").notNull(),
+  content: text3("content").notNull(),
+  frontmatter: jsonb2("frontmatter").notNull(),
+  changeSummary: text3("change_summary"),
+  createdBy: uuid3("created_by"),
+  createdAt: timestamp3("created_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  uniqueIndex("instruction_versions_instruction_version_idx").on(table.instructionId, table.versionNumber)
+]);
+
+// ../../packages/db/dist/schema/tables/projects.js
+var projects = pgTable4("projects", {
+  id: uuid4("id").primaryKey().defaultRandom(),
+  orgId: uuid4("org_id").references(() => organizations.id, { onDelete: "cascade" }),
+  name: text4("name").notNull(),
+  description: text4("description"),
+  // Legacy display field. No longer used as a primary lookup key — see
+  // gitRemoteUrl below. Kept for backward compat on existing UI forms.
+  githubRepo: text4("github_repo"),
+  // Canonicalized git remote URL (e.g. 'github.com/owner/repo'). Primary
+  // identity for project matching, set via canonicalizeRemote() server-side.
+  gitRemoteUrl: text4("git_remote_url"),
+  // SHA of the repo's first commit. Stability anchor — survives URL renames
+  // (transferred repos keep the same root commit). Used as fallback lookup
+  // when remote URL doesn't match.
+  gitRootCommit: text4("git_root_commit"),
+  // Old URLs this project has been known by. Populated when a URL rename
+  // is detected via root-commit match. Future sessions with the old URL
+  // still resolve to this project.
+  gitRemoteAliases: text4("git_remote_aliases").array().notNull().default([]),
+  metadata: jsonb3("metadata"),
+  createdBy: uuid4("created_by"),
+  createdAt: timestamp4("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp4("updated_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  uniqueIndex2("projects_org_name_idx").on(table.orgId, table.name),
+  // Partial unique index — NULLs are allowed (legacy projects with no
+  // remote). See migration 00054.
+  uniqueIndex2("projects_git_remote_url_unique").on(table.gitRemoteUrl).where(sql`${table.gitRemoteUrl} IS NOT NULL`)
+]);
+var projectInstructions = pgTable4("project_instructions", {
+  projectId: uuid4("project_id").references(() => projects.id, { onDelete: "cascade" }).notNull(),
+  instructionId: uuid4("instruction_id").references(() => instructions.id, { onDelete: "cascade" }).notNull(),
+  addedAt: timestamp4("added_at", { withTimezone: true }).defaultNow(),
+  addedBy: uuid4("added_by")
+}, (table) => [
+  primaryKey2({ columns: [table.projectId, table.instructionId] })
+]);
+var projectCheckouts = pgTable4("project_checkouts", {
+  projectId: uuid4("project_id").references(() => projects.id, { onDelete: "cascade" }).notNull(),
+  path: text4("path").notNull(),
+  isWorktree: boolean3("is_worktree").notNull().default(false),
+  firstSeen: timestamp4("first_seen", { withTimezone: true }).notNull().defaultNow(),
+  lastSeen: timestamp4("last_seen", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey2({ columns: [table.projectId, table.path] }),
+  uniqueIndex2("project_checkouts_path_unique").on(table.path)
+]);
+
+// ../../packages/db/dist/schema/tables/agent-runs.js
+var agentRuns = pgTable5("agent_runs", {
+  id: uuid5("id").primaryKey().defaultRandom(),
+  userId: uuid5("user_id").notNull().references(() => profiles.id, { onDelete: "cascade" }),
+  orgId: uuid5("org_id").references(() => organizations.id, { onDelete: "set null" }),
+  projectId: uuid5("project_id").references(() => projects.id, { onDelete: "set null" }),
+  projectPath: text5("project_path"),
+  gitRemote: text5("git_remote"),
+  baseBranch: text5("base_branch"),
+  title: text5("title"),
+  prompt: text5("prompt"),
+  // the shared task fanned out to each session
+  toolSpec: jsonb4("tool_spec").notNull().default([]),
+  // [{tool, model?, label?}] one entry per session
+  autoWorktree: boolean4("auto_worktree").notNull().default(true),
+  // 'pending' | 'running' | 'completed' | 'failed' | 'cancelled' (DB CHECK enforces)
+  status: text5("status").notNull().default("pending"),
+  sessionCount: integer2("session_count").notNull().default(0),
+  metadata: jsonb4("metadata").notNull().default({}),
+  createdAt: timestamp5("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp5("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  completedAt: timestamp5("completed_at", { withTimezone: true })
+}, (table) => [
+  index2("idx_agent_runs_user").on(table.userId),
+  index2("idx_agent_runs_org_created").on(table.orgId, table.createdAt),
+  index2("idx_agent_runs_project").on(table.projectId)
+]);
+
+// ../../packages/db/dist/schema/tables/sessions.js
+import { pgTable as pgTable6, text as text6, timestamp as timestamp6, jsonb as jsonb5, uuid as uuid6, integer as integer3, uniqueIndex as uniqueIndex3, index as index3 } from "drizzle-orm/pg-core";
+var sessions = pgTable6("sessions", {
+  id: uuid6("id").primaryKey().defaultRandom(),
+  userId: uuid6("user_id").notNull().references(() => profiles.id, { onDelete: "cascade" }),
+  externalSessionId: text6("external_session_id"),
+  projectId: uuid6("project_id").references(() => projects.id, { onDelete: "set null" }),
+  orgId: uuid6("org_id").references(() => organizations.id, { onDelete: "set null" }),
+  tool: text6("tool").notNull(),
+  projectPath: text6("project_path"),
+  gitBranch: text6("git_branch"),
+  startedAt: timestamp6("started_at", { withTimezone: true }).notNull(),
+  endedAt: timestamp6("ended_at", { withTimezone: true }),
+  eventCount: integer3("event_count").default(0),
+  tokenUsage: jsonb5("token_usage"),
+  analysis: jsonb5("analysis"),
+  analyzedAt: timestamp6("analyzed_at", { withTimezone: true }),
+  analyzedEventCount: integer3("analyzed_event_count"),
+  analyzedTurnCount: integer3("analyzed_turn_count"),
+  metadata: jsonb5("metadata").default({}),
+  // 'hook' | 'mcp' | 'proxy' | 'internal_worker' | 'import' | 'unknown'
+  // Set on insert in POST /api/sessions. GET /api/sessions defaults to
+  // excluding 'internal_worker' so insights/eval pipeline auto-captures
+  // never appear in the user's Sessions tab. See migration 00050.
+  origin: text6("origin").notNull().default("unknown"),
+  runId: uuid6("run_id").references(() => agentRuns.id, { onDelete: "set null" }),
+  createdAt: timestamp6("created_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  index3("idx_sessions_user").on(table.userId),
+  index3("idx_sessions_tool").on(table.tool),
+  index3("idx_sessions_started_at").on(table.startedAt),
+  index3("idx_sessions_project").on(table.projectId),
+  index3("idx_sessions_org_started_at").on(table.orgId, table.startedAt),
+  index3("idx_sessions_run").on(table.runId),
+  uniqueIndex3("idx_sessions_user_external").on(table.userId, table.externalSessionId)
+]);
+var sessionEvents = pgTable6("session_events", {
+  id: uuid6("id").primaryKey().defaultRandom(),
+  sessionId: uuid6("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  sequence: integer3("sequence").notNull(),
+  eventType: text6("event_type").notNull(),
+  content: text6("content"),
+  toolName: text6("tool_name"),
+  toolInput: jsonb5("tool_input"),
+  toolOutput: jsonb5("tool_output"),
+  tokenUsage: jsonb5("token_usage"),
+  model: text6("model"),
+  timestamp: timestamp6("timestamp", { withTimezone: true }).notNull(),
+  metadata: jsonb5("metadata").default({})
+}, (table) => [
+  uniqueIndex3("session_events_session_sequence_idx").on(table.sessionId, table.sequence),
+  index3("idx_session_events_session_id").on(table.sessionId),
+  index3("idx_session_events_event_type").on(table.eventType),
+  index3("idx_session_events_model").on(table.model)
+]);
+var sessionInstructions = pgTable6("session_instructions", {
+  sessionId: uuid6("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  instructionId: uuid6("instruction_id").notNull().references(() => instructions.id, { onDelete: "cascade" }),
+  linkMethod: text6("link_method").notNull()
+}, (table) => [
+  index3("idx_session_instructions_instruction_id").on(table.instructionId)
+]);
+
+// ../../packages/db/dist/schema/tables/announcements.js
+import { boolean as boolean5, date, index as index4, integer as integer4, jsonb as jsonb6, pgTable as pgTable7, text as text7, timestamp as timestamp7, uniqueIndex as uniqueIndex4, uuid as uuid7 } from "drizzle-orm/pg-core";
+var announcements = pgTable7("announcements", {
+  id: uuid7("id").primaryKey().defaultRandom(),
+  version: text7("version").notNull().unique(),
+  releaseDate: date("release_date").notNull(),
+  subject: text7("subject").notNull(),
+  htmlBody: text7("html_body").notNull(),
+  textBody: text7("text_body").notNull(),
+  sections: jsonb6("sections").notNull().default({}),
+  status: text7("status").notNull().default("draft"),
+  recipientCount: integer4("recipient_count"),
+  sentAt: timestamp7("sent_at", { withTimezone: true }),
+  sentBy: uuid7("sent_by"),
+  error: text7("error"),
+  createdAt: timestamp7("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp7("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  index4("idx_announcements_status").on(table.status),
+  index4("idx_announcements_created").on(table.createdAt)
+]);
+var announcementDeliveries = pgTable7("announcement_deliveries", {
+  id: uuid7("id").primaryKey().defaultRandom(),
+  announcementId: uuid7("announcement_id").notNull(),
+  userId: uuid7("user_id").notNull(),
+  email: text7("email").notNull(),
+  status: text7("status").notNull().default("pending"),
+  providerId: text7("provider_id"),
+  error: text7("error"),
+  sentAt: timestamp7("sent_at", { withTimezone: true }),
+  createdAt: timestamp7("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  uniqueIndex4("uniq_announcement_deliveries_announcement_user").on(table.announcementId, table.userId),
+  index4("idx_announcement_deliveries_user").on(table.userId, table.createdAt)
+]);
+var notificationPreferences = pgTable7("notification_preferences", {
+  userId: uuid7("user_id").primaryKey(),
+  productAnnouncements: boolean5("product_announcements").notNull().default(true),
+  unsubscribeToken: text7("unsubscribe_token").notNull().unique(),
+  unsubscribedAt: timestamp7("unsubscribed_at", { withTimezone: true }),
+  createdAt: timestamp7("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp7("updated_at", { withTimezone: true }).notNull().defaultNow()
+});
+
+// ../../packages/db/dist/schema/tables/org-invitations.js
+import { pgTable as pgTable8, text as text8, timestamp as timestamp8, uuid as uuid8, index as index5 } from "drizzle-orm/pg-core";
+var orgInvitations = pgTable8("org_invitations", {
+  id: uuid8("id").primaryKey().defaultRandom(),
+  orgId: uuid8("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+  email: text8("email").notNull(),
+  role: text8("role").notNull().default("member"),
+  teamId: uuid8("team_id").references(() => teams.id, { onDelete: "set null" }),
+  invitedBy: uuid8("invited_by").notNull().references(() => profiles.id),
+  token: text8("token").notNull().unique(),
+  // expires_at is generated by Postgres via `default (now() + interval '7 days')`,
+  // so no Drizzle-side default — just notNull.
+  expiresAt: timestamp8("expires_at", { withTimezone: true }).notNull(),
+  acceptedAt: timestamp8("accepted_at", { withTimezone: true }),
+  revokedAt: timestamp8("revoked_at", { withTimezone: true }),
+  createdAt: timestamp8("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (t) => [
+  index5("idx_org_invitations_token").on(t.token),
+  index5("idx_org_invitations_org").on(t.orgId)
+]);
+
+// ../../packages/db/dist/schema/tables/instruction-events.js
+import { pgTable as pgTable9, text as text9, timestamp as timestamp9, jsonb as jsonb7, uuid as uuid9, index as index6 } from "drizzle-orm/pg-core";
+var instructionEvents = pgTable9("instruction_events", {
+  id: uuid9("id").primaryKey().defaultRandom(),
+  instructionId: uuid9("instruction_id").notNull().references(() => instructions.id, { onDelete: "cascade" }),
+  eventType: text9("event_type").notNull(),
+  actorId: uuid9("actor_id").notNull(),
+  metadata: jsonb7("metadata"),
+  createdAt: timestamp9("created_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  index6("idx_instruction_events_instruction").on(table.instructionId),
+  index6("idx_instruction_events_type").on(table.eventType)
+]);
+
+// ../../packages/db/dist/schema/tables/session-terminal-targets.js
+import { pgTable as pgTable10, text as text10, timestamp as timestamp10, uuid as uuid10, jsonb as jsonb8, uniqueIndex as uniqueIndex5, index as index7 } from "drizzle-orm/pg-core";
+var sessionTerminalTargets = pgTable10("session_terminal_targets", {
+  id: uuid10("id").primaryKey().defaultRandom(),
+  userId: uuid10("user_id").notNull().references(() => profiles.id, { onDelete: "cascade" }),
+  sessionId: uuid10("session_id").references(() => sessions.id, { onDelete: "set null" }),
+  externalSessionId: text10("external_session_id"),
+  kind: text10("kind").notNull(),
+  target: text10("target").notNull(),
+  status: text10("status").notNull().default("active"),
+  attachCommand: text10("attach_command").notNull(),
+  projectPath: text10("project_path"),
+  metadata: jsonb8("metadata").notNull().default({}),
+  lastSeenAt: timestamp10("last_seen_at", { withTimezone: true }).defaultNow(),
+  createdAt: timestamp10("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp10("updated_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  uniqueIndex5("idx_session_terminal_targets_user_target").on(table.userId, table.target),
+  index7("idx_session_terminal_targets_session").on(table.sessionId),
+  index7("idx_session_terminal_targets_user_status").on(table.userId, table.status)
+]);
+
+// ../../packages/db/dist/schema/tables/session-send-jobs.js
+import { boolean as boolean6, bigint, index as index8, jsonb as jsonb9, pgTable as pgTable11, text as text11, timestamp as timestamp11, uuid as uuid11, integer as integer5 } from "drizzle-orm/pg-core";
+var sessionSendJobs = pgTable11("session_send_jobs", {
+  id: uuid11("id").primaryKey().defaultRandom(),
+  userId: uuid11("user_id").notNull(),
+  sessionId: uuid11("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  terminalTargetId: uuid11("terminal_target_id").references(() => sessionTerminalTargets.id, { onDelete: "set null" }),
+  target: text11("target").notNull(),
+  message: text11("message").notNull(),
+  submit: boolean6("submit").notNull().default(true),
+  delivery: text11("delivery").notNull().default("live"),
+  status: text11("status").notNull().default("pending"),
+  result: jsonb9("result"),
+  error: text11("error"),
+  attempts: integer5("attempts").notNull().default(0),
+  graphileJobId: bigint("graphile_job_id", { mode: "number" }),
+  taskKind: text11("task_kind"),
+  payload: jsonb9("payload"),
+  claimedBy: text11("claimed_by"),
+  claimedAt: timestamp11("claimed_at", { withTimezone: true }),
+  leaseExpiresAt: timestamp11("lease_expires_at", { withTimezone: true }),
+  createdAt: timestamp11("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp11("updated_at", { withTimezone: true }).defaultNow(),
+  completedAt: timestamp11("completed_at", { withTimezone: true })
+}, (table) => [
+  index8("idx_session_send_jobs_user").on(table.userId),
+  index8("idx_session_send_jobs_session").on(table.sessionId),
+  index8("idx_session_send_jobs_status").on(table.status),
+  index8("idx_session_send_jobs_pending").on(table.userId, table.status)
+]);
+
+// ../../packages/db/dist/schema/tables/packs.js
+import { pgTable as pgTable12, text as text12, timestamp as timestamp12, jsonb as jsonb10, uuid as uuid12, integer as integer6, boolean as boolean7, uniqueIndex as uniqueIndex6, index as index9, primaryKey as primaryKey3 } from "drizzle-orm/pg-core";
+var packs = pgTable12("packs", {
+  id: uuid12("id").primaryKey().defaultRandom(),
+  name: text12("name").notNull(),
+  description: text12("description").notNull(),
+  scope: text12("scope").notNull(),
+  scopeRef: uuid12("scope_ref"),
+  version: text12("version").notNull().default("1.0.0"),
+  tags: text12("tags").array(),
+  badge: text12("badge"),
+  metadata: jsonb10("metadata"),
+  createdBy: uuid12("created_by"),
+  createdAt: timestamp12("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp12("updated_at", { withTimezone: true }).defaultNow(),
+  archived: boolean7("archived").default(false),
+  archivedAt: timestamp12("archived_at", { withTimezone: true }),
+  archivedBy: uuid12("archived_by"),
+  forkedFromId: uuid12("forked_from_id").references(() => packs.id, { onDelete: "set null" }),
+  upstreamVersion: text12("upstream_version")
+}, (table) => [
+  uniqueIndex6("packs_name_scope_ref_idx").on(table.name, table.scope, table.scopeRef),
+  index9("idx_packs_scope").on(table.scope, table.scopeRef),
+  index9("idx_packs_created_by").on(table.createdBy)
+]);
+var packInstructions = pgTable12("pack_instructions", {
+  packId: uuid12("pack_id").references(() => packs.id, { onDelete: "cascade" }).notNull(),
+  instructionId: uuid12("instruction_id").references(() => instructions.id, { onDelete: "cascade" }).notNull(),
+  position: integer6("position").notNull().default(0),
+  slotOverrides: jsonb10("slot_overrides"),
+  addedAt: timestamp12("added_at", { withTimezone: true }).defaultNow(),
+  addedBy: uuid12("added_by")
+}, (table) => [
+  primaryKey3({ columns: [table.packId, table.instructionId] })
+]);
+
+// ../../packages/db/dist/schema/tables/project-signals.js
+import { pgTable as pgTable13, text as text13, timestamp as timestamp13, uuid as uuid13, index as index10, primaryKey as primaryKey4 } from "drizzle-orm/pg-core";
+var projectSignals = pgTable13("project_signals", {
+  userId: uuid13("user_id").notNull().references(() => profiles.id, { onDelete: "cascade" }),
+  projectPath: text13("project_path").notNull(),
+  detectedLanguages: text13("detected_languages").array().notNull().default([]).$type(),
+  lastSeenAt: timestamp13("last_seen_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey4({ columns: [table.userId, table.projectPath] }),
+  index10("idx_project_signals_user_seen").on(table.userId, table.lastSeenAt)
+]);
+
+// ../../packages/db/dist/schema/tables/usage-events.js
+import { pgTable as pgTable14, text as text14, timestamp as timestamp14, jsonb as jsonb11, uuid as uuid14, index as index11 } from "drizzle-orm/pg-core";
+var instructionUsageEvents = pgTable14("instruction_usage_events", {
+  id: uuid14("id").primaryKey().defaultRandom(),
+  instructionId: uuid14("instruction_id").references(() => instructions.id, { onDelete: "set null" }),
+  userId: uuid14("user_id").notNull(),
+  surface: text14("surface").notNull(),
+  action: text14("action").notNull(),
+  metadata: jsonb11("metadata"),
+  traceId: text14("trace_id"),
+  createdAt: timestamp14("created_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  index11("idx_usage_events_instruction").on(table.instructionId),
+  index11("idx_usage_events_user").on(table.userId),
+  index11("idx_usage_events_surface").on(table.surface),
+  index11("idx_usage_events_action").on(table.action),
+  index11("idx_usage_events_created_at").on(table.createdAt),
+  index11("idx_usage_events_user_created").on(table.userId, table.createdAt)
+]);
+
+// ../../packages/db/dist/schema/tables/worker-connections.js
+import { pgTable as pgTable15, text as text15, timestamp as timestamp15, jsonb as jsonb12, uuid as uuid15, index as index12 } from "drizzle-orm/pg-core";
+var workerConnections = pgTable15("worker_connections", {
+  id: uuid15("id").primaryKey().defaultRandom(),
+  userId: uuid15("user_id").notNull(),
+  workerType: text15("worker_type").notNull().default("mcp"),
+  clientName: text15("client_name").notNull(),
+  clientVersion: text15("client_version"),
+  workerVersion: text15("worker_version"),
+  lastHeartbeat: timestamp15("last_heartbeat", { withTimezone: true }).notNull().defaultNow(),
+  connectedAt: timestamp15("connected_at", { withTimezone: true }).notNull().defaultNow(),
+  metadata: jsonb12("metadata")
+}, (table) => [
+  index12("idx_worker_connections_user").on(table.userId),
+  index12("idx_worker_connections_heartbeat").on(table.userId, table.lastHeartbeat),
+  index12("idx_worker_connections_type").on(table.userId, table.workerType)
+]);
+
+// ../../packages/db/dist/schema/tables/eval-targets.js
+import { pgTable as pgTable16, text as text16, timestamp as timestamp16, jsonb as jsonb13, uuid as uuid16, integer as integer7, index as index13 } from "drizzle-orm/pg-core";
+var evalTargets = pgTable16("eval_targets", {
+  id: uuid16("id").primaryKey().defaultRandom(),
+  userId: uuid16("user_id").notNull(),
+  name: text16("name").notNull(),
+  type: text16("type").notNull(),
+  content: text16("content").notNull(),
+  description: text16("description").notNull().default(""),
+  metadata: jsonb13("metadata").notNull().default({}),
+  version: integer7("version").notNull().default(1),
+  parentId: uuid16("parent_id").references(() => evalTargets.id, { onDelete: "set null" }),
+  createdAt: timestamp16("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp16("updated_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  index13("eval_targets_name_user_idx").on(table.name, table.userId),
+  index13("idx_eval_targets_user").on(table.userId),
+  index13("idx_eval_targets_type").on(table.type),
+  index13("idx_eval_targets_parent").on(table.parentId)
+]);
+var evals = pgTable16("evals", {
+  id: uuid16("id").primaryKey().defaultRandom(),
+  evalTargetId: uuid16("eval_target_id").notNull().references(() => evalTargets.id, { onDelete: "cascade" }),
+  name: text16("name").notNull(),
+  prompt: text16("prompt").notNull(),
+  expectedOutput: text16("expected_output").notNull().default(""),
+  files: jsonb13("files").notNull().default([]),
+  expectations: jsonb13("expectations").notNull().default([]),
+  createdAt: timestamp16("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp16("updated_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  index13("idx_evals_target").on(table.evalTargetId)
+]);
+var evalRuns = pgTable16("eval_runs", {
+  id: uuid16("id").primaryKey().defaultRandom(),
+  evalId: uuid16("eval_id").notNull().references(() => evals.id, { onDelete: "cascade" }),
+  evalTargetId: uuid16("eval_target_id").notNull().references(() => evalTargets.id, { onDelete: "cascade" }),
+  evalTargetVersion: integer7("eval_target_version").notNull(),
+  configuration: text16("configuration").notNull(),
+  runNumber: integer7("run_number").notNull().default(1),
+  iteration: integer7("iteration").notNull().default(1),
+  status: text16("status").notNull().default("completed"),
+  outputs: jsonb13("outputs").notNull().default({}),
+  timing: jsonb13("timing").notNull().default({}),
+  grading: jsonb13("grading").notNull().default({}),
+  comparison: jsonb13("comparison"),
+  createdAt: timestamp16("created_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  index13("idx_eval_runs_eval").on(table.evalId),
+  index13("idx_eval_runs_target").on(table.evalTargetId),
+  index13("idx_eval_runs_iteration").on(table.evalTargetId, table.iteration)
+]);
+var benchmarks = pgTable16("benchmarks", {
+  id: uuid16("id").primaryKey().defaultRandom(),
+  evalTargetId: uuid16("eval_target_id").notNull().references(() => evalTargets.id, { onDelete: "cascade" }),
+  iteration: integer7("iteration").notNull().default(1),
+  runSummary: jsonb13("run_summary").notNull().default({}),
+  notes: jsonb13("notes").notNull().default([]),
+  feedback: jsonb13("feedback"),
+  createdAt: timestamp16("created_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  index13("idx_benchmarks_target").on(table.evalTargetId)
+]);
+
+// ../../packages/db/dist/schema/tables/optimization.js
+import { pgTable as pgTable17, text as text17, timestamp as timestamp17, jsonb as jsonb14, uuid as uuid17, integer as integer8, index as index14, real } from "drizzle-orm/pg-core";
+var triggerEvals = pgTable17("trigger_evals", {
+  id: uuid17("id").primaryKey().defaultRandom(),
+  evalTargetId: uuid17("eval_target_id").notNull().references(() => evalTargets.id, { onDelete: "cascade" }),
+  userId: uuid17("user_id").notNull(),
+  queries: jsonb14("queries").notNull().default([]),
+  status: text17("status").notNull().default("pending_review"),
+  trainIndices: integer8("train_indices").array().default([]),
+  testIndices: integer8("test_indices").array().default([]),
+  createdAt: timestamp17("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp17("updated_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  index14("idx_trigger_evals_target").on(table.evalTargetId),
+  index14("idx_trigger_evals_user").on(table.userId)
+]);
+var optimizationRuns = pgTable17("optimization_runs", {
+  id: uuid17("id").primaryKey().defaultRandom(),
+  evalTargetId: uuid17("eval_target_id").notNull().references(() => evalTargets.id, { onDelete: "cascade" }),
+  userId: uuid17("user_id").notNull(),
+  type: text17("type").notNull(),
+  iteration: integer8("iteration").notNull(),
+  inputVersion: integer8("input_version").notNull(),
+  outputVersion: integer8("output_version"),
+  trainScore: real("train_score"),
+  testScore: real("test_score"),
+  analysis: jsonb14("analysis").notNull().default({}),
+  status: text17("status").notNull().default("running"),
+  createdAt: timestamp17("created_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  index14("idx_optimization_runs_target").on(table.evalTargetId),
+  index14("idx_optimization_runs_user").on(table.userId)
+]);
+
+// ../../packages/db/dist/schema/tables/context-snapshots.js
+import { pgTable as pgTable18, text as text18, timestamp as timestamp18, jsonb as jsonb15, uuid as uuid18, integer as integer9, real as real2, index as index15, uniqueIndex as uniqueIndex7 } from "drizzle-orm/pg-core";
+var contextSnapshots = pgTable18("context_snapshots", {
+  id: uuid18("id").primaryKey().defaultRandom(),
+  sessionId: uuid18("session_id").references(() => sessions.id, { onDelete: "cascade" }),
+  userId: uuid18("user_id").notNull().references(() => profiles.id, { onDelete: "cascade" }),
+  sequence: integer9("sequence").notNull().default(0),
+  provider: text18("provider").notNull(),
+  model: text18("model").notNull(),
+  systemPrompt: text18("system_prompt").notNull(),
+  injectedInstructions: jsonb15("injected_instructions").notNull().default([]),
+  messagesSummary: jsonb15("messages_summary").notNull(),
+  tools: jsonb15("tools").notNull().default([]),
+  // Deprecated: use content_blobs via tools_hash
+  systemHash: text18("system_hash").notNull(),
+  requestHash: text18("request_hash").notNull().default(""),
+  toolsHash: text18("tools_hash"),
+  injectedHash: text18("injected_hash"),
+  messagesDelta: jsonb15("messages_delta").default([]),
+  // Storage pointer set when messages_delta is offloaded to the snapshot-deltas
+  // bucket (Stage 1+). NULL = inline (messages_delta populated) OR pruned (both
+  // NULL — see 00101). docs/plans/2026-06-24-messages-delta-object-storage-offload.md
+  messagesDeltaRef: text18("messages_delta_ref"),
+  maxTokens: integer9("max_tokens"),
+  temperature: real2("temperature"),
+  estimatedTokens: integer9("estimated_tokens"),
+  capturedAt: timestamp18("captured_at", { withTimezone: true }).notNull().defaultNow(),
+  metadata: jsonb15("metadata").default({})
+}, (table) => [
+  index15("idx_context_snapshots_session").on(table.sessionId),
+  index15("idx_context_snapshots_user").on(table.userId),
+  index15("idx_context_snapshots_hash").on(table.systemHash),
+  index15("idx_context_snapshots_request_hash").on(table.requestHash),
+  uniqueIndex7("idx_snapshots_session_request").on(table.sessionId, table.requestHash),
+  // Concurrent snapshot POSTs for one session must not reuse a sequence — stops
+  // the live duplicate-sequence corruption. Built via migration 00095.
+  // Pool/perf audit 2026-06-22.
+  uniqueIndex7("idx_snapshots_session_sequence").on(table.sessionId, table.sequence)
+]);
+
+// ../../packages/db/dist/schema/tables/content-blobs.js
+import { pgTable as pgTable19, text as text19, timestamp as timestamp19, jsonb as jsonb16, integer as integer10, index as index16 } from "drizzle-orm/pg-core";
+var contentBlobs = pgTable19("content_blobs", {
+  hash: text19("hash").primaryKey(),
+  contentType: text19("content_type").notNull(),
+  content: jsonb16("content").notNull(),
+  sizeBytes: integer10("size_bytes").notNull().default(0),
+  createdAt: timestamp19("created_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  index16("idx_content_blobs_type").on(table.contentType)
+]);
+
+// ../../packages/db/dist/schema/tables/eval-jobs.js
+import { pgTable as pgTable20, text as text20, timestamp as timestamp20, jsonb as jsonb17, uuid as uuid19, index as index17, integer as integer11, bigint as bigint2 } from "drizzle-orm/pg-core";
+var evalJobs = pgTable20("eval_jobs", {
+  id: uuid19("id").primaryKey().defaultRandom(),
+  userId: uuid19("user_id").notNull(),
+  evalTargetId: uuid19("eval_target_id").notNull().references(() => evalTargets.id, { onDelete: "cascade" }),
+  status: text20("status").notNull().default("pending"),
+  config: jsonb17("config").notNull().default({}),
+  progress: jsonb17("progress").notNull().default({}),
+  result: jsonb17("result"),
+  error: text20("error"),
+  attempts: integer11("attempts").notNull().default(0),
+  graphileJobId: bigint2("graphile_job_id", { mode: "number" }),
+  taskKind: text20("task_kind"),
+  payload: jsonb17("payload"),
+  claimedBy: text20("claimed_by"),
+  claimedAt: timestamp20("claimed_at", { withTimezone: true }),
+  leaseExpiresAt: timestamp20("lease_expires_at", { withTimezone: true }),
+  createdAt: timestamp20("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp20("updated_at", { withTimezone: true }).defaultNow(),
+  completedAt: timestamp20("completed_at", { withTimezone: true })
+}, (table) => [
+  index17("idx_eval_jobs_user").on(table.userId),
+  index17("idx_eval_jobs_target").on(table.evalTargetId),
+  index17("idx_eval_jobs_status").on(table.status),
+  index17("idx_eval_jobs_pending").on(table.userId, table.status)
+]);
+
+// ../../packages/db/dist/schema/tables/agent-jobs.js
+import { pgTable as pgTable21, text as text21, timestamp as timestamp21, jsonb as jsonb18, uuid as uuid20, integer as integer12, index as index18 } from "drizzle-orm/pg-core";
+var agentJobs = pgTable21("agent_jobs", {
+  id: uuid20("id").primaryKey().defaultRandom(),
+  userId: uuid20("user_id").notNull(),
+  taskKind: text21("task_kind").notNull(),
+  status: text21("status").notNull().default("pending"),
+  payload: jsonb18("payload").notNull(),
+  dedupeKey: text21("dedupe_key"),
+  result: jsonb18("result"),
+  error: text21("error"),
+  attempts: integer12("attempts").notNull().default(0),
+  claimedBy: text21("claimed_by"),
+  claimedAt: timestamp21("claimed_at", { withTimezone: true }),
+  leaseExpiresAt: timestamp21("lease_expires_at", { withTimezone: true }),
+  createdAt: timestamp21("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp21("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  completedAt: timestamp21("completed_at", { withTimezone: true })
+}, (table) => [
+  index18("idx_agent_jobs_claim").on(table.userId, table.status, table.taskKind, table.createdAt),
+  index18("idx_agent_jobs_dedupe").on(table.userId, table.taskKind, table.dedupeKey)
+]);
+
+// ../../packages/db/dist/schema/tables/insights.js
+import { pgTable as pgTable22, text as text22, timestamp as timestamp22, jsonb as jsonb19, uuid as uuid21, index as index19, uniqueIndex as uniqueIndex8, integer as integer13, bigint as bigint3 } from "drizzle-orm/pg-core";
+var insightsJobs = pgTable22("insights_jobs", {
+  id: uuid21("id").primaryKey().defaultRandom(),
+  userId: uuid21("user_id").notNull(),
+  status: text22("status").notNull().default("pending"),
+  projectPath: text22("project_path"),
+  // Canonical project identity (project_path-keying fragments one project across
+  // worktrees/subdirs/cwds — migration 00104). Nullable: legacy/unlinked rows fall
+  // back to project_path. Stamped at enqueue when resolvable.
+  projectId: uuid21("project_id").references(() => projects.id, { onDelete: "set null" }),
+  config: jsonb19("config").notNull().default({}),
+  progress: jsonb19("progress").notNull().default({}),
+  result: jsonb19("result"),
+  error: text22("error"),
+  attempts: integer13("attempts").notNull().default(0),
+  graphileJobId: bigint3("graphile_job_id", { mode: "number" }),
+  taskKind: text22("task_kind"),
+  payload: jsonb19("payload"),
+  claimedBy: text22("claimed_by"),
+  claimedAt: timestamp22("claimed_at", { withTimezone: true }),
+  leaseExpiresAt: timestamp22("lease_expires_at", { withTimezone: true }),
+  createdAt: timestamp22("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp22("updated_at", { withTimezone: true }).defaultNow(),
+  completedAt: timestamp22("completed_at", { withTimezone: true })
+}, (table) => [
+  index19("idx_insights_jobs_user").on(table.userId),
+  index19("idx_insights_jobs_status").on(table.status),
+  index19("idx_insights_jobs_pending").on(table.userId, table.status),
+  index19("idx_insights_jobs_project").on(table.projectId)
+]);
+var insightsReports = pgTable22("insights_reports", {
+  id: uuid21("id").primaryKey().defaultRandom(),
+  userId: uuid21("user_id").notNull(),
+  projectPath: text22("project_path"),
+  data: jsonb19("data").notNull(),
+  reportHtml: text22("report_html"),
+  createdAt: timestamp22("created_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  index19("idx_insights_user").on(table.userId),
+  index19("idx_insights_created").on(table.createdAt),
+  uniqueIndex8("idx_insights_user_project").on(table.userId, table.projectPath)
+]);
+
+// ../../packages/db/dist/schema/tables/api-keys.js
+import { pgTable as pgTable23, text as text23, timestamp as timestamp23, uuid as uuid22, index as index20, uniqueIndex as uniqueIndex9 } from "drizzle-orm/pg-core";
+var apiKeys = pgTable23("api_keys", {
+  id: uuid22("id").primaryKey().defaultRandom(),
+  userId: uuid22("user_id").notNull().references(() => profiles.id, { onDelete: "cascade" }),
+  name: text23("name").notNull(),
+  keyHash: text23("key_hash").notNull(),
+  keyPrefix: text23("key_prefix").notNull(),
+  lastUsedAt: timestamp23("last_used_at", { withTimezone: true }),
+  expiresAt: timestamp23("expires_at", { withTimezone: true }),
+  revokedAt: timestamp23("revoked_at", { withTimezone: true }),
+  createdAt: timestamp23("created_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  index20("idx_api_keys_user").on(table.userId),
+  uniqueIndex9("idx_api_keys_hash").on(table.keyHash)
+]);
+
+// ../../packages/db/dist/schema/tables/extension-auth-codes.js
+import { pgTable as pgTable24, text as text24, timestamp as timestamp24, uuid as uuid23, index as index21 } from "drizzle-orm/pg-core";
+var extensionAuthCodes = pgTable24("extension_auth_codes", {
+  code: text24("code").primaryKey(),
+  userId: uuid23("user_id").notNull().references(() => profiles.id, { onDelete: "cascade" }),
+  editor: text24("editor"),
+  email: text24("email"),
+  expiresAt: timestamp24("expires_at", { withTimezone: true }).notNull(),
+  createdAt: timestamp24("created_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  index21("idx_ext_auth_codes_expiry").on(table.expiresAt)
+]);
+
+// ../../packages/db/dist/schema/tables/eval-conversations.js
+import { pgTable as pgTable25, text as text25, timestamp as timestamp25, jsonb as jsonb20, uuid as uuid24, index as index22 } from "drizzle-orm/pg-core";
+var evalConversations = pgTable25("eval_conversations", {
+  id: uuid24("id").primaryKey().defaultRandom(),
+  evalTargetId: uuid24("eval_target_id").notNull().references(() => evalTargets.id, { onDelete: "cascade" }),
+  userId: uuid24("user_id").notNull(),
+  messages: jsonb20("messages").notNull().default([]),
+  status: text25("status").notNull().default("active"),
+  createdAt: timestamp25("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp25("updated_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  index22("idx_eval_conversations_target").on(table.evalTargetId),
+  index22("idx_eval_conversations_user").on(table.userId)
+]);
+
+// ../../packages/db/dist/schema/tables/security-events.js
+import { pgTable as pgTable26, uuid as uuid25, text as text26, jsonb as jsonb21, timestamp as timestamp26, index as index23 } from "drizzle-orm/pg-core";
+var securityEvents = pgTable26("security_events", {
+  id: uuid25("id").primaryKey().defaultRandom(),
+  eventType: text26("event_type").notNull(),
+  severity: text26("severity").notNull(),
+  category: text26("category").notNull(),
+  source: text26("source").notNull(),
+  entityType: text26("entity_type"),
+  entityId: uuid25("entity_id"),
+  userId: uuid25("user_id"),
+  details: jsonb21("details").notNull().default({}),
+  createdAt: timestamp26("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  index23("idx_security_events_type").on(table.eventType),
+  index23("idx_security_events_user").on(table.userId),
+  index23("idx_security_events_created").on(table.createdAt),
+  index23("idx_security_events_severity").on(table.severity),
+  index23("idx_security_events_source").on(table.source)
+]);
+
+// ../../packages/db/dist/schema/tables/tasks.js
+import { pgTable as pgTable27, text as text27, timestamp as timestamp27, uuid as uuid26, index as index24 } from "drizzle-orm/pg-core";
+var tasks = pgTable27("tasks", {
+  id: uuid26("id").primaryKey().defaultRandom(),
+  title: text27("title").notNull(),
+  description: text27("description"),
+  status: text27("status").notNull().default("pending"),
+  createdBy: uuid26("created_by"),
+  createdAt: timestamp27("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp27("updated_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  index24("tasks_created_by_idx").on(table.createdBy),
+  index24("tasks_status_idx").on(table.status)
+]);
+
+// ../../packages/db/dist/schema/tables/skill-submissions.js
+import { pgTable as pgTable28, text as text28, timestamp as timestamp28, jsonb as jsonb22, uuid as uuid27 } from "drizzle-orm/pg-core";
+var skillSubmissions = pgTable28("skill_submissions", {
+  id: uuid27("id").primaryKey().defaultRandom(),
+  skillId: text28("skill_id").notNull(),
+  name: text28("name").notNull(),
+  description: text28("description").notNull(),
+  category: text28("category").notNull(),
+  tools: text28("tools").array().notNull(),
+  tags: text28("tags").array().default([]),
+  content: text28("content").notNull(),
+  status: text28("status").notNull().default("pending"),
+  // pending | approved | rejected
+  submittedBy: uuid27("submitted_by").notNull(),
+  reviewedBy: uuid27("reviewed_by"),
+  reviewNote: text28("review_note"),
+  metadata: jsonb22("metadata"),
+  createdAt: timestamp28("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp28("updated_at", { withTimezone: true }).defaultNow()
+});
+
+// ../../packages/db/dist/schema/tables/harness-releases.js
+import { pgTable as pgTable29, text as text29, timestamp as timestamp29, jsonb as jsonb23, uuid as uuid28, uniqueIndex as uniqueIndex10, index as index25 } from "drizzle-orm/pg-core";
+var harnessReleases = pgTable29("harness_releases", {
+  id: uuid28("id").primaryKey().defaultRandom(),
+  harness: text29("harness").notNull(),
+  // "claude_code", "cursor", "copilot"
+  version: text29("version").notNull(),
+  // "v2.1.119"
+  publishedAt: timestamp29("published_at", { withTimezone: true }).notNull(),
+  title: text29("title"),
+  // release name
+  body: text29("body"),
+  // raw markdown
+  categories: jsonb23("categories").default({}),
+  // { features: string[], fixes: string[], security: string[] }
+  url: text29("url"),
+  // link to release page
+  createdAt: timestamp29("created_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  uniqueIndex10("idx_harness_releases_unique").on(table.harness, table.version),
+  index25("idx_harness_releases_harness").on(table.harness),
+  index25("idx_harness_releases_published").on(table.publishedAt)
+]);
+
+// ../../packages/db/dist/schema/tables/notifications.js
+import { pgTable as pgTable30, text as text30, timestamp as timestamp30, jsonb as jsonb24, uuid as uuid29, index as index26, uniqueIndex as uniqueIndex11 } from "drizzle-orm/pg-core";
+var notifications = pgTable30("notifications", {
+  id: uuid29("id").primaryKey().defaultRandom(),
+  userId: uuid29("user_id").notNull(),
+  type: text30("type").notNull(),
+  title: text30("title").notNull(),
+  body: text30("body"),
+  url: text30("url"),
+  sourceTable: text30("source_table"),
+  sourceId: text30("source_id"),
+  metadata: jsonb24("metadata").notNull().default({}),
+  readAt: timestamp30("read_at", { withTimezone: true }),
+  createdAt: timestamp30("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  index26("idx_notifications_user_created").on(table.userId, table.createdAt),
+  index26("idx_notifications_user_unread").on(table.userId),
+  uniqueIndex11("idx_notifications_source_dedup").on(table.userId, table.sourceTable, table.sourceId)
+]);
+
+// ../../packages/db/dist/schema/tables/launch-jobs.js
+import { pgTable as pgTable31, text as text31, timestamp as timestamp31, jsonb as jsonb25, uuid as uuid30, index as index27, integer as integer14, bigint as bigint4 } from "drizzle-orm/pg-core";
+var launchJobs = pgTable31("launch_jobs", {
+  id: uuid30("id").primaryKey().defaultRandom(),
+  userId: uuid30("user_id").notNull(),
+  tool: text31("tool").notNull(),
+  status: text31("status").notNull().default("pending"),
+  config: jsonb25("config").notNull().default({}),
+  result: jsonb25("result"),
+  error: text31("error"),
+  attempts: integer14("attempts").notNull().default(0),
+  graphileJobId: bigint4("graphile_job_id", { mode: "number" }),
+  taskKind: text31("task_kind"),
+  payload: jsonb25("payload"),
+  claimedBy: text31("claimed_by"),
+  claimedAt: timestamp31("claimed_at", { withTimezone: true }),
+  leaseExpiresAt: timestamp31("lease_expires_at", { withTimezone: true }),
+  createdAt: timestamp31("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp31("updated_at", { withTimezone: true }).defaultNow(),
+  completedAt: timestamp31("completed_at", { withTimezone: true }),
+  runId: uuid30("run_id").references(() => agentRuns.id, { onDelete: "set null" })
+}, (table) => [
+  index27("idx_launch_jobs_user").on(table.userId),
+  index27("idx_launch_jobs_status").on(table.status),
+  index27("idx_launch_jobs_pending").on(table.userId, table.status),
+  index27("idx_launch_jobs_run").on(table.runId)
+]);
+
+// ../../packages/db/dist/schema/tables/instruction-suggestions.js
+import { pgTable as pgTable32, uuid as uuid31, text as text32, real as real3, timestamp as timestamp32, boolean as boolean8, uniqueIndex as uniqueIndex12, index as index28 } from "drizzle-orm/pg-core";
+var instructionSuggestions = pgTable32("instruction_suggestions", {
+  id: uuid31("id").primaryKey().defaultRandom(),
+  userId: uuid31("user_id").notNull().references(() => profiles.id, { onDelete: "cascade" }),
+  instructionId: uuid31("instruction_id").notNull().references(() => instructions.id, { onDelete: "cascade" }),
+  projectPath: text32("project_path").notNull(),
+  // Canonical project identity (migration 00104). Additive + nullable; the
+  // unique index below stays on project_path (NOT NULL) so upserts are
+  // unchanged. Readers prefer project_id to aggregate across path variants.
+  projectId: uuid31("project_id").references(() => projects.id, { onDelete: "set null" }),
+  score: real3("score").notNull(),
+  reason: text32("reason").notNull(),
+  generatedAt: timestamp32("generated_at", { withTimezone: true }).notNull().defaultNow(),
+  isStale: boolean8("is_stale").notNull().default(false),
+  dismissedAt: timestamp32("dismissed_at", { withTimezone: true }),
+  acceptedAt: timestamp32("accepted_at", { withTimezone: true }),
+  promotedToInstructionId: uuid31("promoted_to_instruction_id").references(() => instructions.id, { onDelete: "set null" })
+}, (table) => [
+  uniqueIndex12("idx_instruction_suggestions_user_project_instruction").on(table.userId, table.projectPath, table.instructionId),
+  index28("idx_instruction_suggestions_user_project").on(table.userId, table.projectPath),
+  index28("idx_instruction_suggestions_user_proj_id").on(table.userId, table.projectId),
+  index28("idx_instruction_suggestions_generated_at").on(table.generatedAt)
+]);
+var instructionSuggestionEvents = pgTable32("instruction_suggestion_events", {
+  id: uuid31("id").primaryKey().defaultRandom(),
+  suggestionId: uuid31("suggestion_id").notNull().references(() => instructionSuggestions.id, { onDelete: "cascade" }),
+  userId: uuid31("user_id").notNull().references(() => profiles.id, { onDelete: "cascade" }),
+  eventType: text32("event_type").notNull(),
+  tool: text32("tool"),
+  sessionId: uuid31("session_id"),
+  projectPath: text32("project_path").notNull(),
+  createdAt: timestamp32("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  index28("idx_instruction_suggestion_events_suggestion_id").on(table.suggestionId),
+  index28("idx_instruction_suggestion_events_user_id").on(table.userId)
+]);
+
+// ../../packages/db/dist/schema/tables/model-pricing.js
+import { pgTable as pgTable33, text as text33, integer as integer15, numeric, timestamp as timestamp33, index as index29, primaryKey as primaryKey5 } from "drizzle-orm/pg-core";
+var modelPricing = pgTable33("model_pricing", {
+  provider: text33("provider").notNull(),
+  modelId: text33("model_id").notNull(),
+  inputPerM: numeric("input_per_m").notNull(),
+  outputPerM: numeric("output_per_m").notNull(),
+  cacheReadPerM: numeric("cache_read_per_m").notNull(),
+  cacheWrite5mPerM: numeric("cache_write_5m_per_m").notNull(),
+  cacheWrite1hPerM: numeric("cache_write_1h_per_m").notNull(),
+  contextWindow: integer15("context_window"),
+  effectiveFrom: timestamp33("effective_from", { withTimezone: true }).notNull(),
+  effectiveUntil: timestamp33("effective_until", { withTimezone: true }),
+  source: text33("source").notNull()
+}, (table) => [
+  primaryKey5({ columns: [table.provider, table.modelId, table.effectiveFrom] }),
+  index29("idx_model_pricing_active").on(table.provider, table.modelId, table.effectiveFrom.desc())
+]);
+
+// ../../packages/db/dist/schema/tables/limit-observations.js
+import { pgTable as pgTable34, text as text34, numeric as numeric2, timestamp as timestamp34, uuid as uuid32, jsonb as jsonb26, index as index30 } from "drizzle-orm/pg-core";
+var limitObservations = pgTable34("limit_observations", {
+  id: uuid32("id").primaryKey().defaultRandom(),
+  observedAt: timestamp34("observed_at", { withTimezone: true }).notNull().defaultNow(),
+  provider: text34("provider").notNull(),
+  plan: text34("plan").notNull(),
+  limitType: text34("limit_type").notNull(),
+  value: numeric2("value").notNull(),
+  unit: text34("unit").notNull(),
+  comparator: text34("comparator").notNull().default("="),
+  resetsAt: timestamp34("resets_at", { withTimezone: true }),
+  sourceType: text34("source_type").notNull(),
+  sourceUrl: text34("source_url"),
+  sourceEvidence: jsonb26("source_evidence"),
+  confidence: numeric2("confidence").notNull(),
+  userId: uuid32("user_id")
+}, (table) => [
+  index30("idx_limit_obs_lookup").on(table.provider, table.plan, table.limitType, table.observedAt.desc()),
+  index30("idx_limit_obs_user").on(table.userId, table.observedAt.desc())
+]);
+
+// ../../packages/db/dist/schema/tables/provider-docs-snapshots.js
+import { pgTable as pgTable35, text as text35, timestamp as timestamp35, uuid as uuid33, jsonb as jsonb27, boolean as boolean9, uniqueIndex as uniqueIndex13 } from "drizzle-orm/pg-core";
+var providerDocsSnapshots = pgTable35("provider_docs_snapshots", {
+  id: uuid33("id").primaryKey().defaultRandom(),
+  fetchedAt: timestamp35("fetched_at", { withTimezone: true }).notNull().defaultNow(),
+  provider: text35("provider").notNull(),
+  docUrl: text35("doc_url").notNull(),
+  contentHash: text35("content_hash").notNull(),
+  content: text35("content").notNull(),
+  parseSuccess: boolean9("parse_success").notNull(),
+  parseErrors: jsonb27("parse_errors")
+}, (table) => [
+  uniqueIndex13("idx_docs_dedup").on(table.provider, table.docUrl, table.contentHash)
+]);
+
+// ../../packages/db/dist/schema/tables/plan-limits-active.js
+import { pgTable as pgTable36, text as text36, numeric as numeric3, timestamp as timestamp36, uuid as uuid34, primaryKey as primaryKey6, index as index31 } from "drizzle-orm/pg-core";
+var planLimitsActive = pgTable36("plan_limits_active", {
+  provider: text36("provider").notNull(),
+  plan: text36("plan").notNull(),
+  limitType: text36("limit_type").notNull(),
+  value: numeric3("value").notNull(),
+  unit: text36("unit").notNull(),
+  effectiveFrom: timestamp36("effective_from", { withTimezone: true }).notNull(),
+  effectiveUntil: timestamp36("effective_until", { withTimezone: true }),
+  confidence: numeric3("confidence").notNull(),
+  sourceObservationIds: uuid34("source_observation_ids").array().notNull()
+}, (table) => [
+  primaryKey6({ columns: [table.provider, table.plan, table.limitType, table.effectiveFrom] }),
+  index31("idx_plan_limits_lookup").on(table.provider, table.plan, table.limitType, table.effectiveFrom.desc())
+]);
+
+// ../../packages/db/dist/schema/tables/alert-dispatches.js
+import { pgTable as pgTable37, text as text37, timestamp as timestamp37, uuid as uuid35, jsonb as jsonb28, index as index32 } from "drizzle-orm/pg-core";
+var alertDispatches = pgTable37("alert_dispatches", {
+  id: uuid35("id").primaryKey().defaultRandom(),
+  userId: uuid35("user_id").notNull(),
+  alertKey: text37("alert_key").notNull(),
+  // 'soft' | 'approaching' | 'imminent' | 'hit'
+  severity: text37("severity").notNull(),
+  lastDispatchedAt: timestamp37("last_dispatched_at", { withTimezone: true }).notNull().defaultNow(),
+  // { used_percentage, resets_at, ... } — snapshot of the input that fired this alert.
+  lastState: jsonb28("last_state").notNull(),
+  // 'in_app' | 'vscode' | 'banner'
+  channel: text37("channel").notNull()
+}, (table) => [
+  index32("idx_alert_user_key").on(table.userId, table.alertKey, table.lastDispatchedAt.desc())
+]);
+
+// ../../packages/db/dist/client.js
+import { createClient } from "@supabase/supabase-js";
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+
+// ../../packages/db/dist/schema/index.js
+var schema_exports = {};
+__export(schema_exports, {
+  INSTRUCTION_SCOPES: () => INSTRUCTION_SCOPES,
+  ORG_ROLES: () => ORG_ROLES,
+  agentJobs: () => agentJobs,
+  agentRuns: () => agentRuns,
+  agentRunsRelations: () => agentRunsRelations,
+  alertDispatches: () => alertDispatches,
+  announcementDeliveries: () => announcementDeliveries,
+  announcements: () => announcements,
+  apiKeys: () => apiKeys,
+  apiKeysRelations: () => apiKeysRelations,
+  benchmarks: () => benchmarks,
+  benchmarksRelations: () => benchmarksRelations,
+  contentBlobs: () => contentBlobs,
+  contextSnapshots: () => contextSnapshots,
+  contextSnapshotsRelations: () => contextSnapshotsRelations,
+  evalConversations: () => evalConversations,
+  evalConversationsRelations: () => evalConversationsRelations,
+  evalJobs: () => evalJobs,
+  evalJobsRelations: () => evalJobsRelations,
+  evalRuns: () => evalRuns,
+  evalRunsRelations: () => evalRunsRelations,
+  evalTargets: () => evalTargets,
+  evalTargetsRelations: () => evalTargetsRelations,
+  evals: () => evals,
+  evalsRelations: () => evalsRelations,
+  extensionAuthCodes: () => extensionAuthCodes,
+  harnessReleases: () => harnessReleases,
+  insightsJobs: () => insightsJobs,
+  insightsReports: () => insightsReports,
+  instructionEvents: () => instructionEvents,
+  instructionEventsRelations: () => instructionEventsRelations,
+  instructionSuggestionEvents: () => instructionSuggestionEvents,
+  instructionSuggestions: () => instructionSuggestions,
+  instructionUsageEvents: () => instructionUsageEvents,
+  instructionUsageEventsRelations: () => instructionUsageEventsRelations,
+  instructionVersions: () => instructionVersions,
+  instructionVersionsRelations: () => instructionVersionsRelations,
+  instructions: () => instructions,
+  instructionsRelations: () => instructionsRelations,
+  launchJobs: () => launchJobs,
+  launchJobsRelations: () => launchJobsRelations,
+  limitObservations: () => limitObservations,
+  modelPricing: () => modelPricing,
+  notificationPreferences: () => notificationPreferences,
+  notifications: () => notifications,
+  optimizationRuns: () => optimizationRuns,
+  optimizationRunsRelations: () => optimizationRunsRelations,
+  orgInvitations: () => orgInvitations,
+  orgInvitationsRelations: () => orgInvitationsRelations,
+  organizations: () => organizations,
+  organizationsRelations: () => organizationsRelations,
+  packInstructions: () => packInstructions,
+  packInstructionsRelations: () => packInstructionsRelations,
+  packs: () => packs,
+  packsRelations: () => packsRelations,
+  planLimitsActive: () => planLimitsActive,
+  profiles: () => profiles,
+  profilesRelations: () => profilesRelations,
+  projectCheckouts: () => projectCheckouts,
+  projectInstructions: () => projectInstructions,
+  projectInstructionsRelations: () => projectInstructionsRelations,
+  projectSignals: () => projectSignals,
+  projects: () => projects,
+  projectsRelations: () => projectsRelations,
+  providerDocsSnapshots: () => providerDocsSnapshots,
+  securityEvents: () => securityEvents,
+  sessionEvents: () => sessionEvents,
+  sessionEventsRelations: () => sessionEventsRelations,
+  sessionInstructions: () => sessionInstructions,
+  sessionInstructionsRelations: () => sessionInstructionsRelations,
+  sessionSendJobs: () => sessionSendJobs,
+  sessionTerminalTargets: () => sessionTerminalTargets,
+  sessions: () => sessions,
+  sessionsRelations: () => sessionsRelations,
+  skillSubmissions: () => skillSubmissions,
+  tasks: () => tasks,
+  teams: () => teams,
+  teamsRelations: () => teamsRelations,
+  triggerEvals: () => triggerEvals,
+  triggerEvalsRelations: () => triggerEvalsRelations,
+  userOrganizations: () => userOrganizations,
+  userOrganizationsRelations: () => userOrganizationsRelations,
+  userTeams: () => userTeams,
+  userTeamsRelations: () => userTeamsRelations,
+  workerConnections: () => workerConnections
+});
+
+// ../../packages/db/dist/schema/relations.js
+import { relations } from "drizzle-orm";
+var profilesRelations = relations(profiles, ({ many }) => ({
+  sessions: many(sessions),
+  contextSnapshots: many(contextSnapshots),
+  apiKeys: many(apiKeys)
+}));
+var apiKeysRelations = relations(apiKeys, ({ one }) => ({
+  profile: one(profiles, {
+    fields: [apiKeys.userId],
+    references: [profiles.id]
+  })
+}));
+var organizationsRelations = relations(organizations, ({ many }) => ({
+  teams: many(teams),
+  userOrganizations: many(userOrganizations),
+  projects: many(projects),
+  invitations: many(orgInvitations)
+}));
+var teamsRelations = relations(teams, ({ one, many }) => ({
+  organization: one(organizations, {
+    fields: [teams.orgId],
+    references: [organizations.id]
+  }),
+  userTeams: many(userTeams),
+  invitations: many(orgInvitations)
+}));
+var orgInvitationsRelations = relations(orgInvitations, ({ one }) => ({
+  organization: one(organizations, {
+    fields: [orgInvitations.orgId],
+    references: [organizations.id]
+  }),
+  team: one(teams, {
+    fields: [orgInvitations.teamId],
+    references: [teams.id]
+  }),
+  inviter: one(profiles, {
+    fields: [orgInvitations.invitedBy],
+    references: [profiles.id]
+  })
+}));
+var userOrganizationsRelations = relations(userOrganizations, ({ one }) => ({
+  organization: one(organizations, {
+    fields: [userOrganizations.orgId],
+    references: [organizations.id]
+  })
+}));
+var userTeamsRelations = relations(userTeams, ({ one }) => ({
+  team: one(teams, {
+    fields: [userTeams.teamId],
+    references: [teams.id]
+  })
+}));
+var instructionsRelations = relations(instructions, ({ one, many }) => ({
+  versions: many(instructionVersions),
+  projectInstructions: many(projectInstructions),
+  events: many(instructionEvents),
+  usageEvents: many(instructionUsageEvents),
+  sessionInstructions: many(sessionInstructions),
+  packInstructions: many(packInstructions),
+  forkedFrom: one(instructions, {
+    fields: [instructions.forkedFromId],
+    references: [instructions.id]
+  })
+}));
+var instructionEventsRelations = relations(instructionEvents, ({ one }) => ({
+  instruction: one(instructions, {
+    fields: [instructionEvents.instructionId],
+    references: [instructions.id]
+  })
+}));
+var instructionVersionsRelations = relations(instructionVersions, ({ one }) => ({
+  instruction: one(instructions, {
+    fields: [instructionVersions.instructionId],
+    references: [instructions.id]
+  })
+}));
+var projectsRelations = relations(projects, ({ one, many }) => ({
+  organization: one(organizations, {
+    fields: [projects.orgId],
+    references: [organizations.id]
+  }),
+  projectInstructions: many(projectInstructions),
+  sessions: many(sessions)
+}));
+var projectInstructionsRelations = relations(projectInstructions, ({ one }) => ({
+  project: one(projects, {
+    fields: [projectInstructions.projectId],
+    references: [projects.id]
+  }),
+  instruction: one(instructions, {
+    fields: [projectInstructions.instructionId],
+    references: [instructions.id]
+  })
+}));
+var sessionsRelations = relations(sessions, ({ one, many }) => ({
+  profile: one(profiles, {
+    fields: [sessions.userId],
+    references: [profiles.id]
+  }),
+  project: one(projects, {
+    fields: [sessions.projectId],
+    references: [projects.id]
+  }),
+  run: one(agentRuns, {
+    fields: [sessions.runId],
+    references: [agentRuns.id]
+  }),
+  events: many(sessionEvents),
+  sessionInstructions: many(sessionInstructions),
+  contextSnapshots: many(contextSnapshots)
+}));
+var agentRunsRelations = relations(agentRuns, ({ one, many }) => ({
+  profile: one(profiles, {
+    fields: [agentRuns.userId],
+    references: [profiles.id]
+  }),
+  organization: one(organizations, {
+    fields: [agentRuns.orgId],
+    references: [organizations.id]
+  }),
+  project: one(projects, {
+    fields: [agentRuns.projectId],
+    references: [projects.id]
+  }),
+  sessions: many(sessions),
+  launchJobs: many(launchJobs)
+}));
+var launchJobsRelations = relations(launchJobs, ({ one }) => ({
+  run: one(agentRuns, {
+    fields: [launchJobs.runId],
+    references: [agentRuns.id]
+  })
+}));
+var sessionEventsRelations = relations(sessionEvents, ({ one }) => ({
+  session: one(sessions, {
+    fields: [sessionEvents.sessionId],
+    references: [sessions.id]
+  })
+}));
+var sessionInstructionsRelations = relations(sessionInstructions, ({ one }) => ({
+  session: one(sessions, {
+    fields: [sessionInstructions.sessionId],
+    references: [sessions.id]
+  }),
+  instruction: one(instructions, {
+    fields: [sessionInstructions.instructionId],
+    references: [instructions.id]
+  })
+}));
+var packsRelations = relations(packs, ({ one, many }) => ({
+  packInstructions: many(packInstructions),
+  forkedFrom: one(packs, {
+    fields: [packs.forkedFromId],
+    references: [packs.id]
+  })
+}));
+var packInstructionsRelations = relations(packInstructions, ({ one }) => ({
+  pack: one(packs, {
+    fields: [packInstructions.packId],
+    references: [packs.id]
+  }),
+  instruction: one(instructions, {
+    fields: [packInstructions.instructionId],
+    references: [instructions.id]
+  })
+}));
+var instructionUsageEventsRelations = relations(instructionUsageEvents, ({ one }) => ({
+  instruction: one(instructions, {
+    fields: [instructionUsageEvents.instructionId],
+    references: [instructions.id]
+  })
+}));
+var evalTargetsRelations = relations(evalTargets, ({ one, many }) => ({
+  parent: one(evalTargets, {
+    fields: [evalTargets.parentId],
+    references: [evalTargets.id]
+  }),
+  evals: many(evals),
+  evalRuns: many(evalRuns),
+  benchmarks: many(benchmarks),
+  triggerEvals: many(triggerEvals),
+  optimizationRuns: many(optimizationRuns),
+  evalJobs: many(evalJobs),
+  evalConversations: many(evalConversations)
+}));
+var evalsRelations = relations(evals, ({ one, many }) => ({
+  evalTarget: one(evalTargets, {
+    fields: [evals.evalTargetId],
+    references: [evalTargets.id]
+  }),
+  runs: many(evalRuns)
+}));
+var evalRunsRelations = relations(evalRuns, ({ one }) => ({
+  eval: one(evals, {
+    fields: [evalRuns.evalId],
+    references: [evals.id]
+  }),
+  evalTarget: one(evalTargets, {
+    fields: [evalRuns.evalTargetId],
+    references: [evalTargets.id]
+  })
+}));
+var benchmarksRelations = relations(benchmarks, ({ one }) => ({
+  evalTarget: one(evalTargets, {
+    fields: [benchmarks.evalTargetId],
+    references: [evalTargets.id]
+  })
+}));
+var triggerEvalsRelations = relations(triggerEvals, ({ one }) => ({
+  evalTarget: one(evalTargets, {
+    fields: [triggerEvals.evalTargetId],
+    references: [evalTargets.id]
+  })
+}));
+var optimizationRunsRelations = relations(optimizationRuns, ({ one }) => ({
+  evalTarget: one(evalTargets, {
+    fields: [optimizationRuns.evalTargetId],
+    references: [evalTargets.id]
+  })
+}));
+var evalJobsRelations = relations(evalJobs, ({ one }) => ({
+  evalTarget: one(evalTargets, {
+    fields: [evalJobs.evalTargetId],
+    references: [evalTargets.id]
+  })
+}));
+var evalConversationsRelations = relations(evalConversations, ({ one }) => ({
+  evalTarget: one(evalTargets, {
+    fields: [evalConversations.evalTargetId],
+    references: [evalTargets.id]
+  })
+}));
+var contextSnapshotsRelations = relations(contextSnapshots, ({ one }) => ({
+  session: one(sessions, {
+    fields: [contextSnapshots.sessionId],
+    references: [sessions.id]
+  }),
+  profile: one(profiles, {
+    fields: [contextSnapshots.userId],
+    references: [profiles.id]
+  })
+}));
+
+// ../../packages/db/dist/schema/enums.js
+var INSTRUCTION_SCOPES = ["org", "team", "project", "personal"];
+var ORG_ROLES = ["owner", "admin", "member"];
+
+// ../../packages/db/dist/client.js
+var _supabase;
+var _supabaseAdmin;
+var _db;
+var _client;
+var _closed = false;
+var _closing;
+var _probeClient;
+function getEnv(name) {
+  const value = process.env[name];
+  if (!value)
+    throw new Error(`Missing required env var: ${name}`);
+  return value;
+}
+function getSupabase() {
+  if (!_supabase) {
+    _supabase = createClient(getEnv("SUPABASE_URL"), getEnv("SUPABASE_ANON_KEY"));
+  }
+  return _supabase;
+}
+function getSupabaseAdmin() {
+  if (!_supabaseAdmin) {
+    _supabaseAdmin = createClient(getEnv("SUPABASE_URL"), getEnv("SUPABASE_SERVICE_ROLE_KEY"));
+  }
+  return _supabaseAdmin;
+}
+function getDb() {
+  if (_closed) {
+    throw new Error("getDb() called after closeDb(): the connection pool is closed for shutdown. Stop issuing queries (timers/requests) before draining the pool.");
+  }
+  if (!_db) {
+    const appName = process.env.PG_APPLICATION_NAME || "rulemetric";
+    const max = Number(process.env.PG_POOL_MAX) || 3;
+    const connectTimeoutS = Number(process.env.PG_CONNECT_TIMEOUT_S) || 10;
+    const statementTimeoutMs = Number(process.env.PG_STATEMENT_TIMEOUT_MS) || 0;
+    const idleTimeoutS = Number(process.env.PG_IDLE_TIMEOUT) || 5;
+    const keepAliveS = Number(process.env.PG_KEEP_ALIVE_S) || 60;
+    _client = postgres(getEnv("DATABASE_URL"), {
+      prepare: false,
+      max,
+      connect_timeout: connectTimeoutS,
+      idle_timeout: idleTimeoutS,
+      keep_alive: keepAliveS,
+      // Hard rotation cap. Even active connections get closed and replaced
+      // after 5 minutes, defending against long-lived sockets that Supavisor
+      // marks stale for reasons unrelated to idleness (max-lifetime, server
+      // restart, network blip).
+      max_lifetime: 300,
+      connection: {
+        application_name: appName,
+        // postgres-js applies this as the server-side statement_timeout (ms).
+        ...statementTimeoutMs > 0 ? { statement_timeout: statementTimeoutMs } : {}
+      }
+    });
+    _db = drizzle(_client, { schema: schema_exports });
+  }
+  return _db;
+}
+async function closeDb() {
+  if (_closing)
+    return _closing;
+  _closed = true;
+  const c = _client;
+  const p = _probeClient;
+  _client = void 0;
+  _db = void 0;
+  _probeClient = void 0;
+  _closing = Promise.allSettled([
+    c ? c.end({ timeout: 5 }) : Promise.resolve(),
+    p ? p.end({ timeout: 5 }) : Promise.resolve()
+  ]).then(() => {
+  });
+  return _closing;
+}
+var RETRYABLE_CONNECT_CODES = /* @__PURE__ */ new Set([
+  "CONNECT_TIMEOUT",
+  "ETIMEDOUT",
+  "ENOTFOUND",
+  "ECONNREFUSED",
+  "EAI_AGAIN"
+]);
+function isRetryableConnectError(err) {
+  const e = err;
+  const code = e?.code ?? e?.cause?.code ?? e?.errno;
+  return code !== void 0 && RETRYABLE_CONNECT_CODES.has(code);
+}
+var RETRYABLE_RESET_CODES = /* @__PURE__ */ new Set(["CONNECTION_CLOSED", "ECONNRESET", "EPIPE"]);
+function isRetryableResetError(err) {
+  const e = err;
+  const code = e?.code ?? e?.cause?.code ?? e?.errno;
+  return code !== void 0 && RETRYABLE_RESET_CODES.has(code);
+}
+async function withDbRetry(fn, opts = {}) {
+  const attempts = opts.attempts ?? 3;
+  const baseMs = opts.baseMs ?? 100;
+  let lastErr;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      const retryable = isRetryableConnectError(err) || opts.retryResets === true && isRetryableResetError(err);
+      if (i === attempts - 1 || !retryable)
+        throw err;
+      await new Promise((resolve) => setTimeout(resolve, baseMs * 2 ** i));
+    }
+  }
+  throw lastErr;
+}
+var RETRY_ENTRY_METHODS = /* @__PURE__ */ new Set([
+  "select",
+  "selectDistinct",
+  "selectDistinctOn",
+  "insert",
+  "update",
+  "delete",
+  "execute",
+  "with",
+  "$count",
+  "refreshMaterializedView"
+]);
+var READ_ONLY_ENTRY_METHODS = /* @__PURE__ */ new Set([
+  "select",
+  "selectDistinct",
+  "selectDistinctOn",
+  "$count"
+]);
+function wrapBuilder(value, readSafe = false) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") {
+    return value;
+  }
+  return new Proxy(value, {
+    get(target, prop, receiver) {
+      if (prop === "then") {
+        const then = Reflect.get(target, prop, receiver);
+        if (typeof then !== "function")
+          return then;
+        return (onFulfilled, onRejected) => withDbRetry(() => new Promise((resolve, reject) => then.call(target, resolve, reject)), { retryResets: readSafe }).then(onFulfilled, onRejected);
+      }
+      const v = Reflect.get(target, prop, receiver);
+      if (typeof v === "function") {
+        return (...args) => wrapBuilder(v.apply(target, args), readSafe);
+      }
+      return v;
+    }
+  });
+}
+var db = new Proxy({}, {
+  get(_target, prop) {
+    const real4 = getDb();
+    const value = real4[prop];
+    if (typeof prop === "string" && RETRY_ENTRY_METHODS.has(prop) && typeof value === "function") {
+      const readSafe = READ_ONLY_ENTRY_METHODS.has(prop);
+      return (...args) => wrapBuilder(value.apply(real4, args), readSafe);
+    }
+    return value;
+  }
+});
+var supabase = new Proxy({}, {
+  get(_target, prop) {
+    return getSupabase()[prop];
+  }
+});
+var supabaseAdmin = new Proxy({}, {
+  get(_target, prop) {
+    return getSupabaseAdmin()[prop];
+  }
+});
+
+export {
+  profiles,
+  agentRuns,
+  sessions,
+  sessionEvents,
+  announcements,
+  announcementDeliveries,
+  notificationPreferences,
+  getDb,
+  closeDb
+};
+//# sourceMappingURL=chunk-7FAA3YNB.js.map