@rulemetric/cli 0.6.8 → 0.7.0

package/dist/{chunk-6EMZI4Y3.js → chunk-EI5BHWXA.js}

@@ -480,137 +480,157 @@ var cliSetupEvents = pgTable15("cli_setup_events", {
   index12("idx_cli_setup_events_device").on(table.deviceId, table.createdAt)
 ]);
 
-// ../../packages/db/dist/schema/tables/eval-targets.js
-import { pgTable as pgTable16, text as text16, timestamp as timestamp16, jsonb as jsonb14, 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: jsonb14("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: jsonb14("files").notNull().default([]),
-  expectations: jsonb14("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", {
+// ../../packages/db/dist/schema/tables/cli-error-events.js
+import { pgTable as pgTable16, text as text16, integer as integer7, boolean as boolean8, timestamp as timestamp16, jsonb as jsonb14, uuid as uuid16, index as index13 } from "drizzle-orm/pg-core";
+var cliErrorEvents = pgTable16("cli_error_events", {
   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: jsonb14("outputs").notNull().default({}),
-  timing: jsonb14("timing").notNull().default({}),
-  grading: jsonb14("grading").notNull().default({}),
-  comparison: jsonb14("comparison"),
-  createdAt: timestamp16("created_at", { withTimezone: true }).defaultNow()
+  deviceId: text16("device_id"),
+  event: text16("event").notNull(),
+  command: text16("command"),
+  statusCode: integer7("status_code"),
+  message: text16("message"),
+  cliVersion: text16("cli_version"),
+  os: text16("os"),
+  nodeVersion: text16("node_version"),
+  proxied: boolean8("proxied"),
+  props: jsonb14("props").notNull().default({}),
+  createdAt: timestamp16("created_at", { withTimezone: true }).notNull().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)
+  index13("idx_cli_error_events_created").on(table.createdAt),
+  index13("idx_cli_error_events_device").on(table.deviceId, table.createdAt)
 ]);
-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: jsonb14("run_summary").notNull().default({}),
-  notes: jsonb14("notes").notNull().default([]),
-  feedback: jsonb14("feedback"),
-  createdAt: timestamp16("created_at", { withTimezone: true }).defaultNow()
+
+// ../../packages/db/dist/schema/tables/eval-targets.js
+import { pgTable as pgTable17, text as text17, timestamp as timestamp17, jsonb as jsonb15, uuid as uuid17, integer as integer8, index as index14 } from "drizzle-orm/pg-core";
+var evalTargets = pgTable17("eval_targets", {
+  id: uuid17("id").primaryKey().defaultRandom(),
+  userId: uuid17("user_id").notNull(),
+  name: text17("name").notNull(),
+  type: text17("type").notNull(),
+  content: text17("content").notNull(),
+  description: text17("description").notNull().default(""),
+  metadata: jsonb15("metadata").notNull().default({}),
+  version: integer8("version").notNull().default(1),
+  parentId: uuid17("parent_id").references(() => evalTargets.id, { onDelete: "set null" }),
+  createdAt: timestamp17("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp17("updated_at", { withTimezone: true }).defaultNow()
 }, (table) => [
-  index13("idx_benchmarks_target").on(table.evalTargetId)
+  index14("eval_targets_name_user_idx").on(table.name, table.userId),
+  index14("idx_eval_targets_user").on(table.userId),
+  index14("idx_eval_targets_type").on(table.type),
+  index14("idx_eval_targets_parent").on(table.parentId)
 ]);
-
-// ../../packages/db/dist/schema/tables/optimization.js
-import { pgTable as pgTable17, text as text17, timestamp as timestamp17, jsonb as jsonb15, uuid as uuid17, integer as integer8, index as index14, real } from "drizzle-orm/pg-core";
-var triggerEvals = pgTable17("trigger_evals", {
+var evals = pgTable17("evals", {
   id: uuid17("id").primaryKey().defaultRandom(),
   evalTargetId: uuid17("eval_target_id").notNull().references(() => evalTargets.id, { onDelete: "cascade" }),
-  userId: uuid17("user_id").notNull(),
-  queries: jsonb15("queries").notNull().default([]),
-  status: text17("status").notNull().default("pending_review"),
-  trainIndices: integer8("train_indices").array().default([]),
-  testIndices: integer8("test_indices").array().default([]),
+  name: text17("name").notNull(),
+  prompt: text17("prompt").notNull(),
+  expectedOutput: text17("expected_output").notNull().default(""),
+  files: jsonb15("files").notNull().default([]),
+  expectations: jsonb15("expectations").notNull().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)
+  index14("idx_evals_target").on(table.evalTargetId)
 ]);
-var optimizationRuns = pgTable17("optimization_runs", {
+var evalRuns = pgTable17("eval_runs", {
   id: uuid17("id").primaryKey().defaultRandom(),
+  evalId: uuid17("eval_id").notNull().references(() => evals.id, { onDelete: "cascade" }),
   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"),
+  evalTargetVersion: integer8("eval_target_version").notNull(),
+  configuration: text17("configuration").notNull(),
+  runNumber: integer8("run_number").notNull().default(1),
+  iteration: integer8("iteration").notNull().default(1),
+  status: text17("status").notNull().default("completed"),
+  outputs: jsonb15("outputs").notNull().default({}),
+  timing: jsonb15("timing").notNull().default({}),
+  grading: jsonb15("grading").notNull().default({}),
+  comparison: jsonb15("comparison"),
+  createdAt: timestamp17("created_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  index14("idx_eval_runs_eval").on(table.evalId),
+  index14("idx_eval_runs_target").on(table.evalTargetId),
+  index14("idx_eval_runs_iteration").on(table.evalTargetId, table.iteration)
+]);
+var benchmarks = pgTable17("benchmarks", {
+  id: uuid17("id").primaryKey().defaultRandom(),
+  evalTargetId: uuid17("eval_target_id").notNull().references(() => evalTargets.id, { onDelete: "cascade" }),
+  iteration: integer8("iteration").notNull().default(1),
+  runSummary: jsonb15("run_summary").notNull().default({}),
+  notes: jsonb15("notes").notNull().default([]),
+  feedback: jsonb15("feedback"),
+  createdAt: timestamp17("created_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  index14("idx_benchmarks_target").on(table.evalTargetId)
+]);
+
+// ../../packages/db/dist/schema/tables/optimization.js
+import { pgTable as pgTable18, text as text18, timestamp as timestamp18, jsonb as jsonb16, uuid as uuid18, integer as integer9, index as index15, real } from "drizzle-orm/pg-core";
+var triggerEvals = pgTable18("trigger_evals", {
+  id: uuid18("id").primaryKey().defaultRandom(),
+  evalTargetId: uuid18("eval_target_id").notNull().references(() => evalTargets.id, { onDelete: "cascade" }),
+  userId: uuid18("user_id").notNull(),
+  queries: jsonb16("queries").notNull().default([]),
+  status: text18("status").notNull().default("pending_review"),
+  trainIndices: integer9("train_indices").array().default([]),
+  testIndices: integer9("test_indices").array().default([]),
+  createdAt: timestamp18("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp18("updated_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  index15("idx_trigger_evals_target").on(table.evalTargetId),
+  index15("idx_trigger_evals_user").on(table.userId)
+]);
+var optimizationRuns = pgTable18("optimization_runs", {
+  id: uuid18("id").primaryKey().defaultRandom(),
+  evalTargetId: uuid18("eval_target_id").notNull().references(() => evalTargets.id, { onDelete: "cascade" }),
+  userId: uuid18("user_id").notNull(),
+  type: text18("type").notNull(),
+  iteration: integer9("iteration").notNull(),
+  inputVersion: integer9("input_version").notNull(),
+  outputVersion: integer9("output_version"),
   trainScore: real("train_score"),
   testScore: real("test_score"),
-  analysis: jsonb15("analysis").notNull().default({}),
-  status: text17("status").notNull().default("running"),
-  createdAt: timestamp17("created_at", { withTimezone: true }).defaultNow()
+  analysis: jsonb16("analysis").notNull().default({}),
+  status: text18("status").notNull().default("running"),
+  createdAt: timestamp18("created_at", { withTimezone: true }).defaultNow()
 }, (table) => [
-  index14("idx_optimization_runs_target").on(table.evalTargetId),
-  index14("idx_optimization_runs_user").on(table.userId)
+  index15("idx_optimization_runs_target").on(table.evalTargetId),
+  index15("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 jsonb16, 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: jsonb16("injected_instructions").notNull().default([]),
-  messagesSummary: jsonb16("messages_summary").notNull(),
-  tools: jsonb16("tools").notNull().default([]),
+import { pgTable as pgTable19, text as text19, timestamp as timestamp19, jsonb as jsonb17, uuid as uuid19, integer as integer10, real as real2, index as index16, uniqueIndex as uniqueIndex7 } from "drizzle-orm/pg-core";
+var contextSnapshots = pgTable19("context_snapshots", {
+  id: uuid19("id").primaryKey().defaultRandom(),
+  sessionId: uuid19("session_id").references(() => sessions.id, { onDelete: "cascade" }),
+  userId: uuid19("user_id").notNull().references(() => profiles.id, { onDelete: "cascade" }),
+  sequence: integer10("sequence").notNull().default(0),
+  provider: text19("provider").notNull(),
+  model: text19("model").notNull(),
+  systemPrompt: text19("system_prompt").notNull(),
+  injectedInstructions: jsonb17("injected_instructions").notNull().default([]),
+  messagesSummary: jsonb17("messages_summary").notNull(),
+  tools: jsonb17("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: jsonb16("messages_delta").default([]),
+  systemHash: text19("system_hash").notNull(),
+  requestHash: text19("request_hash").notNull().default(""),
+  toolsHash: text19("tools_hash"),
+  injectedHash: text19("injected_hash"),
+  messagesDelta: jsonb17("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"),
+  messagesDeltaRef: text19("messages_delta_ref"),
+  maxTokens: integer10("max_tokens"),
   temperature: real2("temperature"),
-  estimatedTokens: integer9("estimated_tokens"),
-  capturedAt: timestamp18("captured_at", { withTimezone: true }).notNull().defaultNow(),
-  metadata: jsonb16("metadata").default({})
+  estimatedTokens: integer10("estimated_tokens"),
+  capturedAt: timestamp19("captured_at", { withTimezone: true }).notNull().defaultNow(),
+  metadata: jsonb17("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),
+  index16("idx_context_snapshots_session").on(table.sessionId),
+  index16("idx_context_snapshots_user").on(table.userId),
+  index16("idx_context_snapshots_hash").on(table.systemHash),
+  index16("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.
@@ -620,416 +640,416 @@ 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())
+  index16("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 jsonb17, 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: jsonb17("content").notNull(),
-  sizeBytes: integer10("size_bytes").notNull().default(0),
-  createdAt: timestamp19("created_at", { withTimezone: true }).defaultNow()
+import { pgTable as pgTable20, text as text20, timestamp as timestamp20, jsonb as jsonb18, integer as integer11, index as index17 } from "drizzle-orm/pg-core";
+var contentBlobs = pgTable20("content_blobs", {
+  hash: text20("hash").primaryKey(),
+  contentType: text20("content_type").notNull(),
+  content: jsonb18("content").notNull(),
+  sizeBytes: integer11("size_bytes").notNull().default(0),
+  createdAt: timestamp20("created_at", { withTimezone: true }).defaultNow()
 }, (table) => [
-  index16("idx_content_blobs_type").on(table.contentType)
+  index17("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 jsonb18, 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: jsonb18("config").notNull().default({}),
-  progress: jsonb18("progress").notNull().default({}),
-  result: jsonb18("result"),
-  error: text20("error"),
-  attempts: integer11("attempts").notNull().default(0),
-  graphileJobId: bigint2("graphile_job_id", { mode: "number" }),
-  taskKind: text20("task_kind"),
-  payload: jsonb18("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 jsonb19, uuid as uuid20, integer as integer12, index as index18 } from "drizzle-orm/pg-core";
-var agentJobs = pgTable21("agent_jobs", {
+import { pgTable as pgTable21, text as text21, timestamp as timestamp21, jsonb as jsonb19, uuid as uuid20, index as index18, integer as integer12, bigint as bigint2 } from "drizzle-orm/pg-core";
+var evalJobs = pgTable21("eval_jobs", {
   id: uuid20("id").primaryKey().defaultRandom(),
   userId: uuid20("user_id").notNull(),
-  taskKind: text21("task_kind").notNull(),
+  evalTargetId: uuid20("eval_target_id").notNull().references(() => evalTargets.id, { onDelete: "cascade" }),
   status: text21("status").notNull().default("pending"),
-  payload: jsonb19("payload").notNull(),
-  dedupeKey: text21("dedupe_key"),
+  config: jsonb19("config").notNull().default({}),
+  progress: jsonb19("progress").notNull().default({}),
   result: jsonb19("result"),
   error: text21("error"),
   attempts: integer12("attempts").notNull().default(0),
+  graphileJobId: bigint2("graphile_job_id", { mode: "number" }),
+  taskKind: text21("task_kind"),
+  payload: jsonb19("payload"),
   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(),
+  createdAt: timestamp21("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp21("updated_at", { withTimezone: true }).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)
+  index18("idx_eval_jobs_user").on(table.userId),
+  index18("idx_eval_jobs_target").on(table.evalTargetId),
+  index18("idx_eval_jobs_status").on(table.status),
+  index18("idx_eval_jobs_pending").on(table.userId, table.status)
 ]);
 
-// ../../packages/db/dist/schema/tables/insights.js
-import { pgTable as pgTable22, text as text22, timestamp as timestamp22, jsonb as jsonb20, 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", {
+// ../../packages/db/dist/schema/tables/agent-jobs.js
+import { pgTable as pgTable22, text as text22, timestamp as timestamp22, jsonb as jsonb20, uuid as uuid21, integer as integer13, index as index19 } from "drizzle-orm/pg-core";
+var agentJobs = pgTable22("agent_jobs", {
   id: uuid21("id").primaryKey().defaultRandom(),
   userId: uuid21("user_id").notNull(),
+  taskKind: text22("task_kind").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: jsonb20("config").notNull().default({}),
-  progress: jsonb20("progress").notNull().default({}),
+  payload: jsonb20("payload").notNull(),
+  dedupeKey: text22("dedupe_key"),
   result: jsonb20("result"),
   error: text22("error"),
   attempts: integer13("attempts").notNull().default(0),
-  graphileJobId: bigint3("graphile_job_id", { mode: "number" }),
-  taskKind: text22("task_kind"),
-  payload: jsonb20("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(),
+  createdAt: timestamp22("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp22("updated_at", { withTimezone: true }).notNull().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)
+  index19("idx_agent_jobs_claim").on(table.userId, table.status, table.taskKind, table.createdAt),
+  index19("idx_agent_jobs_dedupe").on(table.userId, table.taskKind, table.dedupeKey)
 ]);
-var insightsReports = pgTable22("insights_reports", {
-  id: uuid21("id").primaryKey().defaultRandom(),
-  userId: uuid21("user_id").notNull(),
-  projectPath: text22("project_path"),
-  data: jsonb20("data").notNull(),
-  reportHtml: text22("report_html"),
-  createdAt: timestamp22("created_at", { withTimezone: true }).defaultNow()
+
+// ../../packages/db/dist/schema/tables/insights.js
+import { pgTable as pgTable23, text as text23, timestamp as timestamp23, jsonb as jsonb21, uuid as uuid22, index as index20, uniqueIndex as uniqueIndex8, integer as integer14, bigint as bigint3 } from "drizzle-orm/pg-core";
+var insightsJobs = pgTable23("insights_jobs", {
+  id: uuid22("id").primaryKey().defaultRandom(),
+  userId: uuid22("user_id").notNull(),
+  status: text23("status").notNull().default("pending"),
+  projectPath: text23("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: uuid22("project_id").references(() => projects.id, { onDelete: "set null" }),
+  config: jsonb21("config").notNull().default({}),
+  progress: jsonb21("progress").notNull().default({}),
+  result: jsonb21("result"),
+  error: text23("error"),
+  attempts: integer14("attempts").notNull().default(0),
+  graphileJobId: bigint3("graphile_job_id", { mode: "number" }),
+  taskKind: text23("task_kind"),
+  payload: jsonb21("payload"),
+  claimedBy: text23("claimed_by"),
+  claimedAt: timestamp23("claimed_at", { withTimezone: true }),
+  leaseExpiresAt: timestamp23("lease_expires_at", { withTimezone: true }),
+  createdAt: timestamp23("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp23("updated_at", { withTimezone: true }).defaultNow(),
+  completedAt: timestamp23("completed_at", { withTimezone: true })
 }, (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)
+  index20("idx_insights_jobs_user").on(table.userId),
+  index20("idx_insights_jobs_status").on(table.status),
+  index20("idx_insights_jobs_pending").on(table.userId, table.status),
+  index20("idx_insights_jobs_project").on(table.projectId)
 ]);
-
-// ../../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", {
+var insightsReports = pgTable23("insights_reports", {
   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 }),
+  userId: uuid22("user_id").notNull(),
+  projectPath: text23("project_path"),
+  data: jsonb21("data").notNull(),
+  reportHtml: text23("report_html"),
   createdAt: timestamp23("created_at", { withTimezone: true }).defaultNow()
 }, (table) => [
-  index20("idx_api_keys_user").on(table.userId),
-  uniqueIndex9("idx_api_keys_hash").on(table.keyHash)
+  index20("idx_insights_user").on(table.userId),
+  index20("idx_insights_created").on(table.createdAt),
+  uniqueIndex8("idx_insights_user_project").on(table.userId, table.projectPath)
 ]);
 
-// ../../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(),
+// ../../packages/db/dist/schema/tables/api-keys.js
+import { pgTable as pgTable24, text as text24, timestamp as timestamp24, uuid as uuid23, index as index21, uniqueIndex as uniqueIndex9 } from "drizzle-orm/pg-core";
+var apiKeys = pgTable24("api_keys", {
+  id: uuid23("id").primaryKey().defaultRandom(),
   userId: uuid23("user_id").notNull().references(() => profiles.id, { onDelete: "cascade" }),
-  editor: text24("editor"),
-  email: text24("email"),
-  expiresAt: timestamp24("expires_at", { withTimezone: true }).notNull(),
+  name: text24("name").notNull(),
+  keyHash: text24("key_hash").notNull(),
+  keyPrefix: text24("key_prefix").notNull(),
+  lastUsedAt: timestamp24("last_used_at", { withTimezone: true }),
+  expiresAt: timestamp24("expires_at", { withTimezone: true }),
+  revokedAt: timestamp24("revoked_at", { withTimezone: true }),
   createdAt: timestamp24("created_at", { withTimezone: true }).defaultNow()
 }, (table) => [
-  index21("idx_ext_auth_codes_expiry").on(table.expiresAt)
+  index21("idx_api_keys_user").on(table.userId),
+  uniqueIndex9("idx_api_keys_hash").on(table.keyHash)
 ]);
 
-// ../../packages/db/dist/schema/tables/eval-conversations.js
-import { pgTable as pgTable25, text as text25, timestamp as timestamp25, jsonb as jsonb21, 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: jsonb21("messages").notNull().default([]),
-  status: text25("status").notNull().default("active"),
-  createdAt: timestamp25("created_at", { withTimezone: true }).defaultNow(),
-  updatedAt: timestamp25("updated_at", { withTimezone: true }).defaultNow()
+// ../../packages/db/dist/schema/tables/extension-auth-codes.js
+import { pgTable as pgTable25, text as text25, timestamp as timestamp25, uuid as uuid24, index as index22 } from "drizzle-orm/pg-core";
+var extensionAuthCodes = pgTable25("extension_auth_codes", {
+  code: text25("code").primaryKey(),
+  userId: uuid24("user_id").notNull().references(() => profiles.id, { onDelete: "cascade" }),
+  editor: text25("editor"),
+  email: text25("email"),
+  expiresAt: timestamp25("expires_at", { withTimezone: true }).notNull(),
+  createdAt: timestamp25("created_at", { withTimezone: true }).defaultNow()
 }, (table) => [
-  index22("idx_eval_conversations_target").on(table.evalTargetId),
-  index22("idx_eval_conversations_user").on(table.userId)
+  index22("idx_ext_auth_codes_expiry").on(table.expiresAt)
 ]);
 
-// ../../packages/db/dist/schema/tables/security-events.js
-import { pgTable as pgTable26, uuid as uuid25, text as text26, jsonb as jsonb22, timestamp as timestamp26, index as index23 } from "drizzle-orm/pg-core";
-var securityEvents = pgTable26("security_events", {
+// ../../packages/db/dist/schema/tables/eval-conversations.js
+import { pgTable as pgTable26, text as text26, timestamp as timestamp26, jsonb as jsonb22, uuid as uuid25, index as index23 } from "drizzle-orm/pg-core";
+var evalConversations = pgTable26("eval_conversations", {
   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: jsonb22("details").notNull().default({}),
-  createdAt: timestamp26("created_at", { withTimezone: true }).notNull().defaultNow()
+  evalTargetId: uuid25("eval_target_id").notNull().references(() => evalTargets.id, { onDelete: "cascade" }),
+  userId: uuid25("user_id").notNull(),
+  messages: jsonb22("messages").notNull().default([]),
+  status: text26("status").notNull().default("active"),
+  createdAt: timestamp26("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp26("updated_at", { withTimezone: true }).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)
+  index23("idx_eval_conversations_target").on(table.evalTargetId),
+  index23("idx_eval_conversations_user").on(table.userId)
 ]);
 
-// ../../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", {
+// ../../packages/db/dist/schema/tables/security-events.js
+import { pgTable as pgTable27, uuid as uuid26, text as text27, jsonb as jsonb23, timestamp as timestamp27, index as index24 } from "drizzle-orm/pg-core";
+var securityEvents = pgTable27("security_events", {
   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()
+  eventType: text27("event_type").notNull(),
+  severity: text27("severity").notNull(),
+  category: text27("category").notNull(),
+  source: text27("source").notNull(),
+  entityType: text27("entity_type"),
+  entityId: uuid26("entity_id"),
+  userId: uuid26("user_id"),
+  details: jsonb23("details").notNull().default({}),
+  createdAt: timestamp27("created_at", { withTimezone: true }).notNull().defaultNow()
 }, (table) => [
-  index24("tasks_created_by_idx").on(table.createdBy),
-  index24("tasks_status_idx").on(table.status)
+  index24("idx_security_events_type").on(table.eventType),
+  index24("idx_security_events_user").on(table.userId),
+  index24("idx_security_events_created").on(table.createdAt),
+  index24("idx_security_events_severity").on(table.severity),
+  index24("idx_security_events_source").on(table.source)
 ]);
 
-// ../../packages/db/dist/schema/tables/skill-submissions.js
-import { pgTable as pgTable28, text as text28, timestamp as timestamp28, jsonb as jsonb23, uuid as uuid27 } from "drizzle-orm/pg-core";
-var skillSubmissions = pgTable28("skill_submissions", {
+// ../../packages/db/dist/schema/tables/tasks.js
+import { pgTable as pgTable28, text as text28, timestamp as timestamp28, uuid as uuid27, index as index25 } from "drizzle-orm/pg-core";
+var tasks = pgTable28("tasks", {
   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(),
+  title: text28("title").notNull(),
+  description: text28("description"),
   status: text28("status").notNull().default("pending"),
-  // pending | approved | rejected
-  submittedBy: uuid27("submitted_by").notNull(),
-  reviewedBy: uuid27("reviewed_by"),
-  reviewNote: text28("review_note"),
-  metadata: jsonb23("metadata"),
+  createdBy: uuid27("created_by"),
   createdAt: timestamp28("created_at", { withTimezone: true }).defaultNow(),
   updatedAt: timestamp28("updated_at", { withTimezone: true }).defaultNow()
+}, (table) => [
+  index25("tasks_created_by_idx").on(table.createdBy),
+  index25("tasks_status_idx").on(table.status)
+]);
+
+// ../../packages/db/dist/schema/tables/skill-submissions.js
+import { pgTable as pgTable29, text as text29, timestamp as timestamp29, jsonb as jsonb24, uuid as uuid28 } from "drizzle-orm/pg-core";
+var skillSubmissions = pgTable29("skill_submissions", {
+  id: uuid28("id").primaryKey().defaultRandom(),
+  skillId: text29("skill_id").notNull(),
+  name: text29("name").notNull(),
+  description: text29("description").notNull(),
+  category: text29("category").notNull(),
+  tools: text29("tools").array().notNull(),
+  tags: text29("tags").array().default([]),
+  content: text29("content").notNull(),
+  status: text29("status").notNull().default("pending"),
+  // pending | approved | rejected
+  submittedBy: uuid28("submitted_by").notNull(),
+  reviewedBy: uuid28("reviewed_by"),
+  reviewNote: text29("review_note"),
+  metadata: jsonb24("metadata"),
+  createdAt: timestamp29("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp29("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 jsonb24, 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 pgTable30, text as text30, timestamp as timestamp30, jsonb as jsonb25, uuid as uuid29, uniqueIndex as uniqueIndex10, index as index26 } from "drizzle-orm/pg-core";
+var harnessReleases = pgTable30("harness_releases", {
+  id: uuid29("id").primaryKey().defaultRandom(),
+  harness: text30("harness").notNull(),
   // "claude_code", "cursor", "copilot"
-  version: text29("version").notNull(),
+  version: text30("version").notNull(),
   // "v2.1.119"
-  publishedAt: timestamp29("published_at", { withTimezone: true }).notNull(),
-  title: text29("title"),
+  publishedAt: timestamp30("published_at", { withTimezone: true }).notNull(),
+  title: text30("title"),
   // release name
-  body: text29("body"),
+  body: text30("body"),
   // raw markdown
-  categories: jsonb24("categories").default({}),
+  categories: jsonb25("categories").default({}),
   // { features: string[], fixes: string[], security: string[] }
-  url: text29("url"),
+  url: text30("url"),
   // link to release page
-  createdAt: timestamp29("created_at", { withTimezone: true }).defaultNow()
+  createdAt: timestamp30("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)
+  index26("idx_harness_releases_harness").on(table.harness),
+  index26("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 jsonb25, 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: jsonb25("metadata").notNull().default({}),
-  readAt: timestamp30("read_at", { withTimezone: true }),
-  createdAt: timestamp30("created_at", { withTimezone: true }).notNull().defaultNow()
+import { pgTable as pgTable31, text as text31, timestamp as timestamp31, jsonb as jsonb26, uuid as uuid30, index as index27, uniqueIndex as uniqueIndex11 } from "drizzle-orm/pg-core";
+var notifications = pgTable31("notifications", {
+  id: uuid30("id").primaryKey().defaultRandom(),
+  userId: uuid30("user_id").notNull(),
+  type: text31("type").notNull(),
+  title: text31("title").notNull(),
+  body: text31("body"),
+  url: text31("url"),
+  sourceTable: text31("source_table"),
+  sourceId: text31("source_id"),
+  metadata: jsonb26("metadata").notNull().default({}),
+  readAt: timestamp31("read_at", { withTimezone: true }),
+  createdAt: timestamp31("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),
+  index27("idx_notifications_user_created").on(table.userId, table.createdAt),
+  index27("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 jsonb26, 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: jsonb26("config").notNull().default({}),
-  result: jsonb26("result"),
-  error: text31("error"),
-  attempts: integer14("attempts").notNull().default(0),
+import { pgTable as pgTable32, text as text32, timestamp as timestamp32, jsonb as jsonb27, uuid as uuid31, index as index28, integer as integer15, bigint as bigint4 } from "drizzle-orm/pg-core";
+var launchJobs = pgTable32("launch_jobs", {
+  id: uuid31("id").primaryKey().defaultRandom(),
+  userId: uuid31("user_id").notNull(),
+  tool: text32("tool").notNull(),
+  status: text32("status").notNull().default("pending"),
+  config: jsonb27("config").notNull().default({}),
+  result: jsonb27("result"),
+  error: text32("error"),
+  attempts: integer15("attempts").notNull().default(0),
   graphileJobId: bigint4("graphile_job_id", { mode: "number" }),
-  taskKind: text31("task_kind"),
-  payload: jsonb26("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" })
+  taskKind: text32("task_kind"),
+  payload: jsonb27("payload"),
+  claimedBy: text32("claimed_by"),
+  claimedAt: timestamp32("claimed_at", { withTimezone: true }),
+  leaseExpiresAt: timestamp32("lease_expires_at", { withTimezone: true }),
+  createdAt: timestamp32("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp32("updated_at", { withTimezone: true }).defaultNow(),
+  completedAt: timestamp32("completed_at", { withTimezone: true }),
+  runId: uuid31("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)
+  index28("idx_launch_jobs_user").on(table.userId),
+  index28("idx_launch_jobs_status").on(table.status),
+  index28("idx_launch_jobs_pending").on(table.userId, table.status),
+  index28("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 pgTable33, uuid as uuid32, text as text33, real as real3, timestamp as timestamp33, boolean as boolean9, uniqueIndex as uniqueIndex12, index as index29 } from "drizzle-orm/pg-core";
+var instructionSuggestions = pgTable33("instruction_suggestions", {
+  id: uuid32("id").primaryKey().defaultRandom(),
+  userId: uuid32("user_id").notNull().references(() => profiles.id, { onDelete: "cascade" }),
+  instructionId: uuid32("instruction_id").notNull().references(() => instructions.id, { onDelete: "cascade" }),
+  projectPath: text33("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: uuid32("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" })
+  reason: text33("reason").notNull(),
+  generatedAt: timestamp33("generated_at", { withTimezone: true }).notNull().defaultNow(),
+  isStale: boolean9("is_stale").notNull().default(false),
+  dismissedAt: timestamp33("dismissed_at", { withTimezone: true }),
+  acceptedAt: timestamp33("accepted_at", { withTimezone: true }),
+  promotedToInstructionId: uuid32("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)
+  index29("idx_instruction_suggestions_user_project").on(table.userId, table.projectPath),
+  index29("idx_instruction_suggestions_user_proj_id").on(table.userId, table.projectId),
+  index29("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 = pgTable33("instruction_suggestion_events", {
+  id: uuid32("id").primaryKey().defaultRandom(),
+  suggestionId: uuid32("suggestion_id").notNull().references(() => instructionSuggestions.id, { onDelete: "cascade" }),
+  userId: uuid32("user_id").notNull().references(() => profiles.id, { onDelete: "cascade" }),
+  eventType: text33("event_type").notNull(),
+  tool: text33("tool"),
+  sessionId: uuid32("session_id"),
+  projectPath: text33("project_path").notNull(),
+  createdAt: timestamp33("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)
+  index29("idx_instruction_suggestion_events_suggestion_id").on(table.suggestionId),
+  index29("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 primaryKey4 } from "drizzle-orm/pg-core";
-var modelPricing = pgTable33("model_pricing", {
-  provider: text33("provider").notNull(),
-  modelId: text33("model_id").notNull(),
+import { pgTable as pgTable34, text as text34, integer as integer16, numeric, timestamp as timestamp34, index as index30, primaryKey as primaryKey4 } from "drizzle-orm/pg-core";
+var modelPricing = pgTable34("model_pricing", {
+  provider: text34("provider").notNull(),
+  modelId: text34("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()
+  contextWindow: integer16("context_window"),
+  effectiveFrom: timestamp34("effective_from", { withTimezone: true }).notNull(),
+  effectiveUntil: timestamp34("effective_until", { withTimezone: true }),
+  source: text34("source").notNull()
 }, (table) => [
   primaryKey4({ columns: [table.provider, table.modelId, table.effectiveFrom] }),
-  index29("idx_model_pricing_active").on(table.provider, table.modelId, table.effectiveFrom.desc())
+  index30("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 jsonb27, 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 pgTable35, text as text35, numeric as numeric2, timestamp as timestamp35, uuid as uuid33, jsonb as jsonb28, index as index31 } from "drizzle-orm/pg-core";
+var limitObservations = pgTable35("limit_observations", {
+  id: uuid33("id").primaryKey().defaultRandom(),
+  observedAt: timestamp35("observed_at", { withTimezone: true }).notNull().defaultNow(),
+  provider: text35("provider").notNull(),
+  plan: text35("plan").notNull(),
+  limitType: text35("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: jsonb27("source_evidence"),
+  unit: text35("unit").notNull(),
+  comparator: text35("comparator").notNull().default("="),
+  resetsAt: timestamp35("resets_at", { withTimezone: true }),
+  sourceType: text35("source_type").notNull(),
+  sourceUrl: text35("source_url"),
+  sourceEvidence: jsonb28("source_evidence"),
   confidence: numeric2("confidence").notNull(),
-  userId: uuid32("user_id")
+  userId: uuid33("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())
+  index31("idx_limit_obs_lookup").on(table.provider, table.plan, table.limitType, table.observedAt.desc()),
+  index31("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 jsonb28, 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: jsonb28("parse_errors")
+import { pgTable as pgTable36, text as text36, timestamp as timestamp36, uuid as uuid34, jsonb as jsonb29, boolean as boolean10, uniqueIndex as uniqueIndex13 } from "drizzle-orm/pg-core";
+var providerDocsSnapshots = pgTable36("provider_docs_snapshots", {
+  id: uuid34("id").primaryKey().defaultRandom(),
+  fetchedAt: timestamp36("fetched_at", { withTimezone: true }).notNull().defaultNow(),
+  provider: text36("provider").notNull(),
+  docUrl: text36("doc_url").notNull(),
+  contentHash: text36("content_hash").notNull(),
+  content: text36("content").notNull(),
+  parseSuccess: boolean10("parse_success").notNull(),
+  parseErrors: jsonb29("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 primaryKey5, 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 pgTable37, text as text37, numeric as numeric3, timestamp as timestamp37, uuid as uuid35, primaryKey as primaryKey5, index as index32 } from "drizzle-orm/pg-core";
+var planLimitsActive = pgTable37("plan_limits_active", {
+  provider: text37("provider").notNull(),
+  plan: text37("plan").notNull(),
+  limitType: text37("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: text37("unit").notNull(),
+  effectiveFrom: timestamp37("effective_from", { withTimezone: true }).notNull(),
+  effectiveUntil: timestamp37("effective_until", { withTimezone: true }),
   confidence: numeric3("confidence").notNull(),
-  sourceObservationIds: uuid34("source_observation_ids").array().notNull()
+  sourceObservationIds: uuid35("source_observation_ids").array().notNull()
 }, (table) => [
   primaryKey5({ columns: [table.provider, table.plan, table.limitType, table.effectiveFrom] }),
-  index31("idx_plan_limits_lookup").on(table.provider, table.plan, table.limitType, table.effectiveFrom.desc())
+  index32("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 jsonb29, 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 pgTable38, text as text38, timestamp as timestamp38, uuid as uuid36, jsonb as jsonb30, index as index33 } from "drizzle-orm/pg-core";
+var alertDispatches = pgTable38("alert_dispatches", {
+  id: uuid36("id").primaryKey().defaultRandom(),
+  userId: uuid36("user_id").notNull(),
+  alertKey: text38("alert_key").notNull(),
   // 'soft' | 'approaching' | 'imminent' | 'hit'
-  severity: text37("severity").notNull(),
-  lastDispatchedAt: timestamp37("last_dispatched_at", { withTimezone: true }).notNull().defaultNow(),
+  severity: text38("severity").notNull(),
+  lastDispatchedAt: timestamp38("last_dispatched_at", { withTimezone: true }).notNull().defaultNow(),
   // { used_percentage, resets_at, ... } — snapshot of the input that fired this alert.
-  lastState: jsonb29("last_state").notNull(),
+  lastState: jsonb30("last_state").notNull(),
   // 'in_app' | 'vscode' | 'banner'
-  channel: text37("channel").notNull()
+  channel: text38("channel").notNull()
 }, (table) => [
-  index32("idx_alert_user_key").on(table.userId, table.alertKey, table.lastDispatchedAt.desc())
+  index33("idx_alert_user_key").on(table.userId, table.alertKey, table.lastDispatchedAt.desc())
 ]);
 
 // ../../packages/db/dist/client.js
@@ -1049,6 +1069,7 @@ __export(schema_exports, {
   apiKeysRelations: () => apiKeysRelations,
   benchmarks: () => benchmarks,
   benchmarksRelations: () => benchmarksRelations,
+  cliErrorEvents: () => cliErrorEvents,
   cliSetupEvents: () => cliSetupEvents,
   contentBlobs: () => contentBlobs,
   contextSnapshots: () => contextSnapshots,
@@ -1371,6 +1392,8 @@ var contextSnapshotsRelations = relations(contextSnapshots, ({ one }) => ({
 // ../../packages/db/dist/db-load.js
 var _inFlight = 0;
 var _peak = 0;
+var _heavyInFlight = 0;
+var _heavyPeak = 0;
 function trackDbOpStart() {
   _inFlight++;
   if (_inFlight > _peak)
@@ -1380,6 +1403,15 @@ function trackDbOpEnd() {
   if (_inFlight > 0)
     _inFlight--;
 }
+function trackHeavyDbOpStart() {
+  _heavyInFlight++;
+  if (_heavyInFlight > _heavyPeak)
+    _heavyPeak = _heavyInFlight;
+}
+function trackHeavyDbOpEnd() {
+  if (_heavyInFlight > 0)
+    _heavyInFlight--;
+}
 
 // ../../packages/db/dist/client.js
 var _db;
@@ -1548,7 +1580,7 @@ var READ_ONLY_ENTRY_METHODS = /* @__PURE__ */ new Set([
   "selectDistinctOn",
   "$count"
 ]);
-function wrapBuilder(value, readSafe = false, deadlineMs = 0) {
+function wrapBuilder(value, readSafe = false, deadlineMs = 0, heavyPool = false) {
   if (value === null || typeof value !== "object" && typeof value !== "function") {
     return value;
   }
@@ -1559,26 +1591,30 @@ function wrapBuilder(value, readSafe = false, deadlineMs = 0) {
         if (typeof then !== "function")
           return then;
         return (onFulfilled, onRejected) => {
-          trackDbOpStart();
+          const opStart = heavyPool ? trackHeavyDbOpStart : trackDbOpStart;
+          const opEnd = heavyPool ? trackHeavyDbOpEnd : trackDbOpEnd;
+          opStart();
           const exec = withDbRetry(() => new Promise((resolve, reject) => then.call(target, resolve, reject)), { retryResets: readSafe });
           const guarded = deadlineMs > 0 ? raceWithDeadline(exec, deadlineMs) : exec;
-          return guarded.finally(trackDbOpEnd).then(onFulfilled, onRejected);
+          return guarded.finally(opEnd).then(onFulfilled, onRejected);
         };
       }
       const v = Reflect.get(target, prop, receiver);
       if (typeof v === "function") {
-        return (...args) => wrapBuilder(v.apply(target, args), readSafe, deadlineMs);
+        return (...args) => wrapBuilder(v.apply(target, args), readSafe, deadlineMs, heavyPool);
       }
       return v;
     }
   });
 }
-function gaugeTransaction(run) {
-  trackDbOpStart();
+function gaugeTransaction(run, heavyPool = false) {
+  const opStart = heavyPool ? trackHeavyDbOpStart : trackDbOpStart;
+  const opEnd = heavyPool ? trackHeavyDbOpEnd : trackDbOpEnd;
+  opStart();
   try {
-    return Promise.resolve(run()).finally(trackDbOpEnd);
+    return Promise.resolve(run()).finally(opEnd);
   } catch (err) {
-    trackDbOpEnd();
+    opEnd();
     throw err;
   }
 }
@@ -1603,10 +1639,10 @@ var heavyDb = new Proxy({}, {
     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 (...args) => wrapBuilder(value.apply(real4, args), readSafe, 0, true);
     }
     if (prop === "transaction" && typeof value === "function") {
-      return (...args) => gaugeTransaction(() => value.apply(real4, args));
+      return (...args) => gaugeTransaction(() => value.apply(real4, args), true);
     }
     return value;
   }
@@ -1623,4 +1659,4 @@ export {
   getDb,
   closeDb
 };
-//# sourceMappingURL=chunk-6EMZI4Y3.js.map
+//# sourceMappingURL=chunk-EI5BHWXA.js.map