@rulemetric/cli 0.5.2 → 0.5.4

package/dist/{chunk-YQFCUKNI.js → chunk-QNSVCSHG.js}

@@ -426,187 +426,175 @@ var packInstructions = pgTable12("pack_instructions", {
   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(),
+import { pgTable as pgTable13, text as text13, timestamp as timestamp13, jsonb as jsonb11, uuid as uuid13, index as index10 } from "drizzle-orm/pg-core";
+var instructionUsageEvents = pgTable13("instruction_usage_events", {
+  id: uuid13("id").primaryKey().defaultRandom(),
+  instructionId: uuid13("instruction_id").references(() => instructions.id, { onDelete: "set null" }),
+  userId: uuid13("user_id").notNull(),
+  surface: text13("surface").notNull(),
+  action: text13("action").notNull(),
   metadata: jsonb11("metadata"),
-  traceId: text14("trace_id"),
-  createdAt: timestamp14("created_at", { withTimezone: true }).defaultNow()
+  traceId: text13("trace_id"),
+  createdAt: timestamp13("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)
+  index10("idx_usage_events_instruction").on(table.instructionId),
+  index10("idx_usage_events_user").on(table.userId),
+  index10("idx_usage_events_surface").on(table.surface),
+  index10("idx_usage_events_action").on(table.action),
+  index10("idx_usage_events_created_at").on(table.createdAt),
+  index10("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(),
+import { pgTable as pgTable14, text as text14, timestamp as timestamp14, jsonb as jsonb12, uuid as uuid14, index as index11 } from "drizzle-orm/pg-core";
+var workerConnections = pgTable14("worker_connections", {
+  id: uuid14("id").primaryKey().defaultRandom(),
+  userId: uuid14("user_id").notNull(),
+  workerType: text14("worker_type").notNull().default("mcp"),
+  clientName: text14("client_name").notNull(),
+  clientVersion: text14("client_version"),
+  workerVersion: text14("worker_version"),
+  lastHeartbeat: timestamp14("last_heartbeat", { withTimezone: true }).notNull().defaultNow(),
+  connectedAt: timestamp14("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)
+  index11("idx_worker_connections_user").on(table.userId),
+  index11("idx_worker_connections_heartbeat").on(table.userId, table.lastHeartbeat),
+  index11("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(""),
+import { pgTable as pgTable15, text as text15, timestamp as timestamp15, jsonb as jsonb13, uuid as uuid15, integer as integer7, index as index12 } from "drizzle-orm/pg-core";
+var evalTargets = pgTable15("eval_targets", {
+  id: uuid15("id").primaryKey().defaultRandom(),
+  userId: uuid15("user_id").notNull(),
+  name: text15("name").notNull(),
+  type: text15("type").notNull(),
+  content: text15("content").notNull(),
+  description: text15("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()
+  parentId: uuid15("parent_id").references(() => evalTargets.id, { onDelete: "set null" }),
+  createdAt: timestamp15("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp15("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)
+  index12("eval_targets_name_user_idx").on(table.name, table.userId),
+  index12("idx_eval_targets_user").on(table.userId),
+  index12("idx_eval_targets_type").on(table.type),
+  index12("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(""),
+var evals = pgTable15("evals", {
+  id: uuid15("id").primaryKey().defaultRandom(),
+  evalTargetId: uuid15("eval_target_id").notNull().references(() => evalTargets.id, { onDelete: "cascade" }),
+  name: text15("name").notNull(),
+  prompt: text15("prompt").notNull(),
+  expectedOutput: text15("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()
+  createdAt: timestamp15("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp15("updated_at", { withTimezone: true }).defaultNow()
 }, (table) => [
-  index13("idx_evals_target").on(table.evalTargetId)
+  index12("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" }),
+var evalRuns = pgTable15("eval_runs", {
+  id: uuid15("id").primaryKey().defaultRandom(),
+  evalId: uuid15("eval_id").notNull().references(() => evals.id, { onDelete: "cascade" }),
+  evalTargetId: uuid15("eval_target_id").notNull().references(() => evalTargets.id, { onDelete: "cascade" }),
   evalTargetVersion: integer7("eval_target_version").notNull(),
-  configuration: text16("configuration").notNull(),
+  configuration: text15("configuration").notNull(),
   runNumber: integer7("run_number").notNull().default(1),
   iteration: integer7("iteration").notNull().default(1),
-  status: text16("status").notNull().default("completed"),
+  status: text15("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()
+  createdAt: timestamp15("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)
+  index12("idx_eval_runs_eval").on(table.evalId),
+  index12("idx_eval_runs_target").on(table.evalTargetId),
+  index12("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" }),
+var benchmarks = pgTable15("benchmarks", {
+  id: uuid15("id").primaryKey().defaultRandom(),
+  evalTargetId: uuid15("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()
+  createdAt: timestamp15("created_at", { withTimezone: true }).defaultNow()
 }, (table) => [
-  index13("idx_benchmarks_target").on(table.evalTargetId)
+  index12("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(),
+import { pgTable as pgTable16, text as text16, timestamp as timestamp16, jsonb as jsonb14, uuid as uuid16, integer as integer8, index as index13, real } from "drizzle-orm/pg-core";
+var triggerEvals = pgTable16("trigger_evals", {
+  id: uuid16("id").primaryKey().defaultRandom(),
+  evalTargetId: uuid16("eval_target_id").notNull().references(() => evalTargets.id, { onDelete: "cascade" }),
+  userId: uuid16("user_id").notNull(),
   queries: jsonb14("queries").notNull().default([]),
-  status: text17("status").notNull().default("pending_review"),
+  status: text16("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()
+  createdAt: timestamp16("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp16("updated_at", { withTimezone: true }).defaultNow()
 }, (table) => [
-  index14("idx_trigger_evals_target").on(table.evalTargetId),
-  index14("idx_trigger_evals_user").on(table.userId)
+  index13("idx_trigger_evals_target").on(table.evalTargetId),
+  index13("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(),
+var optimizationRuns = pgTable16("optimization_runs", {
+  id: uuid16("id").primaryKey().defaultRandom(),
+  evalTargetId: uuid16("eval_target_id").notNull().references(() => evalTargets.id, { onDelete: "cascade" }),
+  userId: uuid16("user_id").notNull(),
+  type: text16("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()
+  status: text16("status").notNull().default("running"),
+  createdAt: timestamp16("created_at", { withTimezone: true }).defaultNow()
 }, (table) => [
-  index14("idx_optimization_runs_target").on(table.evalTargetId),
-  index14("idx_optimization_runs_user").on(table.userId)
+  index13("idx_optimization_runs_target").on(table.evalTargetId),
+  index13("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" }),
+import { pgTable as pgTable17, text as text17, timestamp as timestamp17, jsonb as jsonb15, uuid as uuid17, integer as integer9, real as real2, index as index14, uniqueIndex as uniqueIndex7 } from "drizzle-orm/pg-core";
+var contextSnapshots = pgTable17("context_snapshots", {
+  id: uuid17("id").primaryKey().defaultRandom(),
+  sessionId: uuid17("session_id").references(() => sessions.id, { onDelete: "cascade" }),
+  userId: uuid17("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(),
+  provider: text17("provider").notNull(),
+  model: text17("model").notNull(),
+  systemPrompt: text17("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"),
+  systemHash: text17("system_hash").notNull(),
+  requestHash: text17("request_hash").notNull().default(""),
+  toolsHash: text17("tools_hash"),
+  injectedHash: text17("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"),
+  messagesDeltaRef: text17("messages_delta_ref"),
   maxTokens: integer9("max_tokens"),
   temperature: real2("temperature"),
   estimatedTokens: integer9("estimated_tokens"),
-  capturedAt: timestamp18("captured_at", { withTimezone: true }).notNull().defaultNow(),
+  capturedAt: timestamp17("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),
+  index14("idx_context_snapshots_session").on(table.sessionId),
+  index14("idx_context_snapshots_user").on(table.userId),
+  index14("idx_context_snapshots_hash").on(table.systemHash),
+  index14("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.
@@ -616,378 +604,378 @@ var contextSnapshots = pgTable18("context_snapshots", {
   // WHERE user_id ORDER BY session_id, captured_at DESC). Matches the ORDER BY so
   // the planner drops the Incremental Sort (the ~11s-max, temp-spill-prone step);
   // verified 60.6ms -> 26.3ms. Built CONCURRENTLY via migration 00106.
-  index15("idx_context_snapshots_user_session_captured").on(table.userId, table.sessionId, table.capturedAt.desc())
+  index14("idx_context_snapshots_user_session_captured").on(table.userId, table.sessionId, table.capturedAt.desc())
 ]);
 
 // ../../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(),
+import { pgTable as pgTable18, text as text18, timestamp as timestamp18, jsonb as jsonb16, integer as integer10, index as index15 } from "drizzle-orm/pg-core";
+var contentBlobs = pgTable18("content_blobs", {
+  hash: text18("hash").primaryKey(),
+  contentType: text18("content_type").notNull(),
   content: jsonb16("content").notNull(),
   sizeBytes: integer10("size_bytes").notNull().default(0),
-  createdAt: timestamp19("created_at", { withTimezone: true }).defaultNow()
+  createdAt: timestamp18("created_at", { withTimezone: true }).defaultNow()
 }, (table) => [
-  index16("idx_content_blobs_type").on(table.contentType)
+  index15("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"),
+import { pgTable as pgTable19, text as text19, timestamp as timestamp19, jsonb as jsonb17, uuid as uuid18, index as index16, integer as integer11, bigint as bigint2 } from "drizzle-orm/pg-core";
+var evalJobs = pgTable19("eval_jobs", {
+  id: uuid18("id").primaryKey().defaultRandom(),
+  userId: uuid18("user_id").notNull(),
+  evalTargetId: uuid18("eval_target_id").notNull().references(() => evalTargets.id, { onDelete: "cascade" }),
+  status: text19("status").notNull().default("pending"),
   config: jsonb17("config").notNull().default({}),
   progress: jsonb17("progress").notNull().default({}),
   result: jsonb17("result"),
-  error: text20("error"),
+  error: text19("error"),
   attempts: integer11("attempts").notNull().default(0),
   graphileJobId: bigint2("graphile_job_id", { mode: "number" }),
-  taskKind: text20("task_kind"),
+  taskKind: text19("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 })
+  claimedBy: text19("claimed_by"),
+  claimedAt: timestamp19("claimed_at", { withTimezone: true }),
+  leaseExpiresAt: timestamp19("lease_expires_at", { withTimezone: true }),
+  createdAt: timestamp19("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp19("updated_at", { withTimezone: true }).defaultNow(),
+  completedAt: timestamp19("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)
+  index16("idx_eval_jobs_user").on(table.userId),
+  index16("idx_eval_jobs_target").on(table.evalTargetId),
+  index16("idx_eval_jobs_status").on(table.status),
+  index16("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"),
+import { pgTable as pgTable20, text as text20, timestamp as timestamp20, jsonb as jsonb18, uuid as uuid19, integer as integer12, index as index17 } from "drizzle-orm/pg-core";
+var agentJobs = pgTable20("agent_jobs", {
+  id: uuid19("id").primaryKey().defaultRandom(),
+  userId: uuid19("user_id").notNull(),
+  taskKind: text20("task_kind").notNull(),
+  status: text20("status").notNull().default("pending"),
   payload: jsonb18("payload").notNull(),
-  dedupeKey: text21("dedupe_key"),
+  dedupeKey: text20("dedupe_key"),
   result: jsonb18("result"),
-  error: text21("error"),
+  error: text20("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 })
+  claimedBy: text20("claimed_by"),
+  claimedAt: timestamp20("claimed_at", { withTimezone: true }),
+  leaseExpiresAt: timestamp20("lease_expires_at", { withTimezone: true }),
+  createdAt: timestamp20("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp20("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  completedAt: timestamp20("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)
+  index17("idx_agent_jobs_claim").on(table.userId, table.status, table.taskKind, table.createdAt),
+  index17("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"),
+import { pgTable as pgTable21, text as text21, timestamp as timestamp21, jsonb as jsonb19, uuid as uuid20, index as index18, uniqueIndex as uniqueIndex8, integer as integer13, bigint as bigint3 } from "drizzle-orm/pg-core";
+var insightsJobs = pgTable21("insights_jobs", {
+  id: uuid20("id").primaryKey().defaultRandom(),
+  userId: uuid20("user_id").notNull(),
+  status: text21("status").notNull().default("pending"),
+  projectPath: text21("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" }),
+  projectId: uuid20("project_id").references(() => projects.id, { onDelete: "set null" }),
   config: jsonb19("config").notNull().default({}),
   progress: jsonb19("progress").notNull().default({}),
   result: jsonb19("result"),
-  error: text22("error"),
+  error: text21("error"),
   attempts: integer13("attempts").notNull().default(0),
   graphileJobId: bigint3("graphile_job_id", { mode: "number" }),
-  taskKind: text22("task_kind"),
+  taskKind: text21("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 })
+  claimedBy: text21("claimed_by"),
+  claimedAt: timestamp21("claimed_at", { withTimezone: true }),
+  leaseExpiresAt: timestamp21("lease_expires_at", { withTimezone: true }),
+  createdAt: timestamp21("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp21("updated_at", { withTimezone: true }).defaultNow(),
+  completedAt: timestamp21("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)
+  index18("idx_insights_jobs_user").on(table.userId),
+  index18("idx_insights_jobs_status").on(table.status),
+  index18("idx_insights_jobs_pending").on(table.userId, table.status),
+  index18("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"),
+var insightsReports = pgTable21("insights_reports", {
+  id: uuid20("id").primaryKey().defaultRandom(),
+  userId: uuid20("user_id").notNull(),
+  projectPath: text21("project_path"),
   data: jsonb19("data").notNull(),
-  reportHtml: text22("report_html"),
-  createdAt: timestamp22("created_at", { withTimezone: true }).defaultNow()
+  reportHtml: text21("report_html"),
+  createdAt: timestamp21("created_at", { withTimezone: true }).defaultNow()
 }, (table) => [
-  index19("idx_insights_user").on(table.userId),
-  index19("idx_insights_created").on(table.createdAt),
+  index18("idx_insights_user").on(table.userId),
+  index18("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()
+import { pgTable as pgTable22, text as text22, timestamp as timestamp22, uuid as uuid21, index as index19, uniqueIndex as uniqueIndex9 } from "drizzle-orm/pg-core";
+var apiKeys = pgTable22("api_keys", {
+  id: uuid21("id").primaryKey().defaultRandom(),
+  userId: uuid21("user_id").notNull().references(() => profiles.id, { onDelete: "cascade" }),
+  name: text22("name").notNull(),
+  keyHash: text22("key_hash").notNull(),
+  keyPrefix: text22("key_prefix").notNull(),
+  lastUsedAt: timestamp22("last_used_at", { withTimezone: true }),
+  expiresAt: timestamp22("expires_at", { withTimezone: true }),
+  revokedAt: timestamp22("revoked_at", { withTimezone: true }),
+  createdAt: timestamp22("created_at", { withTimezone: true }).defaultNow()
 }, (table) => [
-  index20("idx_api_keys_user").on(table.userId),
+  index19("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()
+import { pgTable as pgTable23, text as text23, timestamp as timestamp23, uuid as uuid22, index as index20 } from "drizzle-orm/pg-core";
+var extensionAuthCodes = pgTable23("extension_auth_codes", {
+  code: text23("code").primaryKey(),
+  userId: uuid22("user_id").notNull().references(() => profiles.id, { onDelete: "cascade" }),
+  editor: text23("editor"),
+  email: text23("email"),
+  expiresAt: timestamp23("expires_at", { withTimezone: true }).notNull(),
+  createdAt: timestamp23("created_at", { withTimezone: true }).defaultNow()
 }, (table) => [
-  index21("idx_ext_auth_codes_expiry").on(table.expiresAt)
+  index20("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(),
+import { pgTable as pgTable24, text as text24, timestamp as timestamp24, jsonb as jsonb20, uuid as uuid23, index as index21 } from "drizzle-orm/pg-core";
+var evalConversations = pgTable24("eval_conversations", {
+  id: uuid23("id").primaryKey().defaultRandom(),
+  evalTargetId: uuid23("eval_target_id").notNull().references(() => evalTargets.id, { onDelete: "cascade" }),
+  userId: uuid23("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()
+  status: text24("status").notNull().default("active"),
+  createdAt: timestamp24("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp24("updated_at", { withTimezone: true }).defaultNow()
 }, (table) => [
-  index22("idx_eval_conversations_target").on(table.evalTargetId),
-  index22("idx_eval_conversations_user").on(table.userId)
+  index21("idx_eval_conversations_target").on(table.evalTargetId),
+  index21("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"),
+import { pgTable as pgTable25, uuid as uuid24, text as text25, jsonb as jsonb21, timestamp as timestamp25, index as index22 } from "drizzle-orm/pg-core";
+var securityEvents = pgTable25("security_events", {
+  id: uuid24("id").primaryKey().defaultRandom(),
+  eventType: text25("event_type").notNull(),
+  severity: text25("severity").notNull(),
+  category: text25("category").notNull(),
+  source: text25("source").notNull(),
+  entityType: text25("entity_type"),
+  entityId: uuid24("entity_id"),
+  userId: uuid24("user_id"),
   details: jsonb21("details").notNull().default({}),
-  createdAt: timestamp26("created_at", { withTimezone: true }).notNull().defaultNow()
+  createdAt: timestamp25("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)
+  index22("idx_security_events_type").on(table.eventType),
+  index22("idx_security_events_user").on(table.userId),
+  index22("idx_security_events_created").on(table.createdAt),
+  index22("idx_security_events_severity").on(table.severity),
+  index22("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()
+import { pgTable as pgTable26, text as text26, timestamp as timestamp26, uuid as uuid25, index as index23 } from "drizzle-orm/pg-core";
+var tasks = pgTable26("tasks", {
+  id: uuid25("id").primaryKey().defaultRandom(),
+  title: text26("title").notNull(),
+  description: text26("description"),
+  status: text26("status").notNull().default("pending"),
+  createdBy: uuid25("created_by"),
+  createdAt: timestamp26("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp26("updated_at", { withTimezone: true }).defaultNow()
 }, (table) => [
-  index24("tasks_created_by_idx").on(table.createdBy),
-  index24("tasks_status_idx").on(table.status)
+  index23("tasks_created_by_idx").on(table.createdBy),
+  index23("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"),
+import { pgTable as pgTable27, text as text27, timestamp as timestamp27, jsonb as jsonb22, uuid as uuid26 } from "drizzle-orm/pg-core";
+var skillSubmissions = pgTable27("skill_submissions", {
+  id: uuid26("id").primaryKey().defaultRandom(),
+  skillId: text27("skill_id").notNull(),
+  name: text27("name").notNull(),
+  description: text27("description").notNull(),
+  category: text27("category").notNull(),
+  tools: text27("tools").array().notNull(),
+  tags: text27("tags").array().default([]),
+  content: text27("content").notNull(),
+  status: text27("status").notNull().default("pending"),
   // pending | approved | rejected
-  submittedBy: uuid27("submitted_by").notNull(),
-  reviewedBy: uuid27("reviewed_by"),
-  reviewNote: text28("review_note"),
+  submittedBy: uuid26("submitted_by").notNull(),
+  reviewedBy: uuid26("reviewed_by"),
+  reviewNote: text27("review_note"),
   metadata: jsonb22("metadata"),
-  createdAt: timestamp28("created_at", { withTimezone: true }).defaultNow(),
-  updatedAt: timestamp28("updated_at", { withTimezone: true }).defaultNow()
+  createdAt: timestamp27("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp27("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(),
+import { pgTable as pgTable28, text as text28, timestamp as timestamp28, jsonb as jsonb23, uuid as uuid27, uniqueIndex as uniqueIndex10, index as index24 } from "drizzle-orm/pg-core";
+var harnessReleases = pgTable28("harness_releases", {
+  id: uuid27("id").primaryKey().defaultRandom(),
+  harness: text28("harness").notNull(),
   // "claude_code", "cursor", "copilot"
-  version: text29("version").notNull(),
+  version: text28("version").notNull(),
   // "v2.1.119"
-  publishedAt: timestamp29("published_at", { withTimezone: true }).notNull(),
-  title: text29("title"),
+  publishedAt: timestamp28("published_at", { withTimezone: true }).notNull(),
+  title: text28("title"),
   // release name
-  body: text29("body"),
+  body: text28("body"),
   // raw markdown
   categories: jsonb23("categories").default({}),
   // { features: string[], fixes: string[], security: string[] }
-  url: text29("url"),
+  url: text28("url"),
   // link to release page
-  createdAt: timestamp29("created_at", { withTimezone: true }).defaultNow()
+  createdAt: timestamp28("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)
+  index24("idx_harness_releases_harness").on(table.harness),
+  index24("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"),
+import { pgTable as pgTable29, text as text29, timestamp as timestamp29, jsonb as jsonb24, uuid as uuid28, index as index25, uniqueIndex as uniqueIndex11 } from "drizzle-orm/pg-core";
+var notifications = pgTable29("notifications", {
+  id: uuid28("id").primaryKey().defaultRandom(),
+  userId: uuid28("user_id").notNull(),
+  type: text29("type").notNull(),
+  title: text29("title").notNull(),
+  body: text29("body"),
+  url: text29("url"),
+  sourceTable: text29("source_table"),
+  sourceId: text29("source_id"),
   metadata: jsonb24("metadata").notNull().default({}),
-  readAt: timestamp30("read_at", { withTimezone: true }),
-  createdAt: timestamp30("created_at", { withTimezone: true }).notNull().defaultNow()
+  readAt: timestamp29("read_at", { withTimezone: true }),
+  createdAt: timestamp29("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),
+  index25("idx_notifications_user_created").on(table.userId, table.createdAt),
+  index25("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"),
+import { pgTable as pgTable30, text as text30, timestamp as timestamp30, jsonb as jsonb25, uuid as uuid29, index as index26, integer as integer14, bigint as bigint4 } from "drizzle-orm/pg-core";
+var launchJobs = pgTable30("launch_jobs", {
+  id: uuid29("id").primaryKey().defaultRandom(),
+  userId: uuid29("user_id").notNull(),
+  tool: text30("tool").notNull(),
+  status: text30("status").notNull().default("pending"),
   config: jsonb25("config").notNull().default({}),
   result: jsonb25("result"),
-  error: text31("error"),
+  error: text30("error"),
   attempts: integer14("attempts").notNull().default(0),
   graphileJobId: bigint4("graphile_job_id", { mode: "number" }),
-  taskKind: text31("task_kind"),
+  taskKind: text30("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" })
+  claimedBy: text30("claimed_by"),
+  claimedAt: timestamp30("claimed_at", { withTimezone: true }),
+  leaseExpiresAt: timestamp30("lease_expires_at", { withTimezone: true }),
+  createdAt: timestamp30("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp30("updated_at", { withTimezone: true }).defaultNow(),
+  completedAt: timestamp30("completed_at", { withTimezone: true }),
+  runId: uuid29("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)
+  index26("idx_launch_jobs_user").on(table.userId),
+  index26("idx_launch_jobs_status").on(table.status),
+  index26("idx_launch_jobs_pending").on(table.userId, table.status),
+  index26("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(),
+import { pgTable as pgTable31, uuid as uuid30, text as text31, real as real3, timestamp as timestamp31, boolean as boolean8, uniqueIndex as uniqueIndex12, index as index27 } from "drizzle-orm/pg-core";
+var instructionSuggestions = pgTable31("instruction_suggestions", {
+  id: uuid30("id").primaryKey().defaultRandom(),
+  userId: uuid30("user_id").notNull().references(() => profiles.id, { onDelete: "cascade" }),
+  instructionId: uuid30("instruction_id").notNull().references(() => instructions.id, { onDelete: "cascade" }),
+  projectPath: text31("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" }),
+  projectId: uuid30("project_id").references(() => projects.id, { onDelete: "set null" }),
   score: real3("score").notNull(),
-  reason: text32("reason").notNull(),
-  generatedAt: timestamp32("generated_at", { withTimezone: true }).notNull().defaultNow(),
+  reason: text31("reason").notNull(),
+  generatedAt: timestamp31("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" })
+  dismissedAt: timestamp31("dismissed_at", { withTimezone: true }),
+  acceptedAt: timestamp31("accepted_at", { withTimezone: true }),
+  promotedToInstructionId: uuid30("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)
+  index27("idx_instruction_suggestions_user_project").on(table.userId, table.projectPath),
+  index27("idx_instruction_suggestions_user_proj_id").on(table.userId, table.projectId),
+  index27("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()
+var instructionSuggestionEvents = pgTable31("instruction_suggestion_events", {
+  id: uuid30("id").primaryKey().defaultRandom(),
+  suggestionId: uuid30("suggestion_id").notNull().references(() => instructionSuggestions.id, { onDelete: "cascade" }),
+  userId: uuid30("user_id").notNull().references(() => profiles.id, { onDelete: "cascade" }),
+  eventType: text31("event_type").notNull(),
+  tool: text31("tool"),
+  sessionId: uuid30("session_id"),
+  projectPath: text31("project_path").notNull(),
+  createdAt: timestamp31("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)
+  index27("idx_instruction_suggestion_events_suggestion_id").on(table.suggestionId),
+  index27("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(),
+import { pgTable as pgTable32, text as text32, integer as integer15, numeric, timestamp as timestamp32, index as index28, primaryKey as primaryKey4 } from "drizzle-orm/pg-core";
+var modelPricing = pgTable32("model_pricing", {
+  provider: text32("provider").notNull(),
+  modelId: text32("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()
+  effectiveFrom: timestamp32("effective_from", { withTimezone: true }).notNull(),
+  effectiveUntil: timestamp32("effective_until", { withTimezone: true }),
+  source: text32("source").notNull()
 }, (table) => [
-  primaryKey5({ columns: [table.provider, table.modelId, table.effectiveFrom] }),
-  index29("idx_model_pricing_active").on(table.provider, table.modelId, table.effectiveFrom.desc())
+  primaryKey4({ columns: [table.provider, table.modelId, table.effectiveFrom] }),
+  index28("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(),
+import { pgTable as pgTable33, text as text33, numeric as numeric2, timestamp as timestamp33, uuid as uuid31, jsonb as jsonb26, index as index29 } from "drizzle-orm/pg-core";
+var limitObservations = pgTable33("limit_observations", {
+  id: uuid31("id").primaryKey().defaultRandom(),
+  observedAt: timestamp33("observed_at", { withTimezone: true }).notNull().defaultNow(),
+  provider: text33("provider").notNull(),
+  plan: text33("plan").notNull(),
+  limitType: text33("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"),
+  unit: text33("unit").notNull(),
+  comparator: text33("comparator").notNull().default("="),
+  resetsAt: timestamp33("resets_at", { withTimezone: true }),
+  sourceType: text33("source_type").notNull(),
+  sourceUrl: text33("source_url"),
   sourceEvidence: jsonb26("source_evidence"),
   confidence: numeric2("confidence").notNull(),
-  userId: uuid32("user_id")
+  userId: uuid31("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())
+  index29("idx_limit_obs_lookup").on(table.provider, table.plan, table.limitType, table.observedAt.desc()),
+  index29("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(),
+import { pgTable as pgTable34, text as text34, timestamp as timestamp34, uuid as uuid32, jsonb as jsonb27, boolean as boolean9, uniqueIndex as uniqueIndex13 } from "drizzle-orm/pg-core";
+var providerDocsSnapshots = pgTable34("provider_docs_snapshots", {
+  id: uuid32("id").primaryKey().defaultRandom(),
+  fetchedAt: timestamp34("fetched_at", { withTimezone: true }).notNull().defaultNow(),
+  provider: text34("provider").notNull(),
+  docUrl: text34("doc_url").notNull(),
+  contentHash: text34("content_hash").notNull(),
+  content: text34("content").notNull(),
   parseSuccess: boolean9("parse_success").notNull(),
   parseErrors: jsonb27("parse_errors")
 }, (table) => [
@@ -995,49 +983,46 @@ var providerDocsSnapshots = pgTable35("provider_docs_snapshots", {
 ]);
 
 // ../../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(),
+import { pgTable as pgTable35, text as text35, numeric as numeric3, timestamp as timestamp35, uuid as uuid33, primaryKey as primaryKey5, index as index30 } from "drizzle-orm/pg-core";
+var planLimitsActive = pgTable35("plan_limits_active", {
+  provider: text35("provider").notNull(),
+  plan: text35("plan").notNull(),
+  limitType: text35("limit_type").notNull(),
   value: numeric3("value").notNull(),
-  unit: text36("unit").notNull(),
-  effectiveFrom: timestamp36("effective_from", { withTimezone: true }).notNull(),
-  effectiveUntil: timestamp36("effective_until", { withTimezone: true }),
+  unit: text35("unit").notNull(),
+  effectiveFrom: timestamp35("effective_from", { withTimezone: true }).notNull(),
+  effectiveUntil: timestamp35("effective_until", { withTimezone: true }),
   confidence: numeric3("confidence").notNull(),
-  sourceObservationIds: uuid34("source_observation_ids").array().notNull()
+  sourceObservationIds: uuid33("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())
+  primaryKey5({ columns: [table.provider, table.plan, table.limitType, table.effectiveFrom] }),
+  index30("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(),
+import { pgTable as pgTable36, text as text36, timestamp as timestamp36, uuid as uuid34, jsonb as jsonb28, index as index31 } from "drizzle-orm/pg-core";
+var alertDispatches = pgTable36("alert_dispatches", {
+  id: uuid34("id").primaryKey().defaultRandom(),
+  userId: uuid34("user_id").notNull(),
+  alertKey: text36("alert_key").notNull(),
   // 'soft' | 'approaching' | 'imminent' | 'hit'
-  severity: text37("severity").notNull(),
-  lastDispatchedAt: timestamp37("last_dispatched_at", { withTimezone: true }).notNull().defaultNow(),
+  severity: text36("severity").notNull(),
+  lastDispatchedAt: timestamp36("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()
+  channel: text36("channel").notNull()
 }, (table) => [
-  index32("idx_alert_user_key").on(table.userId, table.alertKey, table.lastDispatchedAt.desc())
+  index31("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,
@@ -1097,7 +1082,6 @@ __export(schema_exports, {
   projectCheckouts: () => projectCheckouts,
   projectInstructions: () => projectInstructions,
   projectInstructionsRelations: () => projectInstructionsRelations,
-  projectSignals: () => projectSignals,
   projects: () => projects,
   projectsRelations: () => projectsRelations,
   providerDocsSnapshots: () => providerDocsSnapshots,
@@ -1367,10 +1351,6 @@ var contextSnapshotsRelations = relations(contextSnapshots, ({ one }) => ({
   })
 }));
 
-// ../../packages/db/dist/schema/enums.js
-var INSTRUCTION_SCOPES = ["org", "team", "project", "personal"];
-var ORG_ROLES = ["owner", "admin", "member"];
-
 // ../../packages/db/dist/db-load.js
 var _inFlight = 0;
 var _peak = 0;
@@ -1385,8 +1365,6 @@ function trackDbOpEnd() {
 }
 
 // ../../packages/db/dist/client.js
-var _supabase;
-var _supabaseAdmin;
 var _db;
 var _client;
 var _closed = false;
@@ -1400,18 +1378,6 @@ function getEnv(name) {
     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.");
@@ -1622,19 +1588,12 @@ var heavyDb = new Proxy({}, {
       const readSafe = READ_ONLY_ENTRY_METHODS.has(prop);
       return (...args) => wrapBuilder(value.apply(real4, args), readSafe);
     }
+    if (prop === "transaction" && typeof value === "function") {
+      return (...args) => gaugeTransaction(() => value.apply(real4, args));
+    }
     return value;
   }
 });
-var supabase = new Proxy({}, {
-  get(_target, prop) {
-    return getSupabase()[prop];
-  }
-});
-var supabaseAdmin = new Proxy({}, {
-  get(_target, prop) {
-    return getSupabaseAdmin()[prop];
-  }
-});
 
 export {
   profiles,
@@ -1647,4 +1606,4 @@ export {
   getDb,
   closeDb
 };
-//# sourceMappingURL=chunk-YQFCUKNI.js.map
+//# sourceMappingURL=chunk-QNSVCSHG.js.map